jack_and_the_elastic_beanstalk 0.1.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4578032c8d9235e27f4491ace04ec78f8929d63f
+  data.tar.gz: '06419fd23e051d5205a536a1c2e6f076819b881c'
+SHA512:
+  metadata.gz: 9886c279514422cb879ca4c7c598cea9a868df7058efebebb9f775bdeb194993ff198bbc189f94345f025459a0ad9aa9ca9b89ff426b25e230f498d3d80f97f5
+  data.tar.gz: 1096c0027dfc9b5e5da7539b9f543bccfca76a8630ad9cdb2caf2ea677af075bba3cb58a12a5f6b207d1d1cea81a69ac7ab4cf07434a2e8c8b14c3ffa0ca660a

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jack_and_the_elastic_beanstalk.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# JackAndTheElasticBeanstalk
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/jack_and_the_elastic_beanstalk`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jack_and_the_elastic_beanstalk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jack_and_the_elastic_beanstalk
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/jack_and_the_elastic_beanstalk.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "jack_and_the_elastic_beanstalk"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/jeb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(__dir__, "../lib")
+require "jack_and_the_elastic_beanstalk"
+
+Dotenv.load
+JackAndTheElasticBeanstalk::CLI.start(ARGV)

data/jack_and_the_elastic_beanstalk.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jack_and_the_elastic_beanstalk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jack_and_the_elastic_beanstalk"
+  spec.version       = JackAndTheElasticBeanstalk::VERSION
+  spec.authors       = ["Soutaro Matsumoto"]
+  spec.email         = ["matsumoto@soutaro.com"]
+
+  spec.summary       = %q{Jack and the Elastic Beanstalk.}
+  spec.description   = %q{Jack and the Elastic Beanstalk.}
+  spec.homepage      = "https://github.com/sideci/jack_and_the_elastic_beanstalk"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+
+  spec.add_runtime_dependency 'dotenv', "~> 2.1"
+  spec.add_runtime_dependency 'rainbow', '~> 2.1'
+  spec.add_runtime_dependency "aws-sdk", "~> 2.6"
+  spec.add_runtime_dependency "thor", "~> 0.19"
+  spec.add_runtime_dependency "parallel", "~> 1.10"
+  spec.add_runtime_dependency "activesupport", "~> 5.0"
+  spec.add_runtime_dependency "rubyzip", "~> 1.2"
+end

data/lib/jack_and_the_elastic_beanstalk/cli.rb

@@ -0,0 +1,345 @@
+module JackAndTheElasticBeanstalk
+  class CLI < Thor
+    no_commands do
+      def client
+        @client ||= Aws::ElasticBeanstalk::Client.new(region: config.region)
+      end
+
+      def runner
+        @runner ||= JackAndTheElasticBeanstalk::Runner.new(stdin: STDIN, stdout: STDOUT, stderr: STDERR, logger: logger)
+      end
+
+      def logger
+        @logger ||= Logger.new(STDERR).tap do |logger|
+          logger.level = Logger.const_get(options[:loglevel].upcase)
+        end
+      end
+
+      def eb
+        @eb ||= JackAndTheElasticBeanstalk::EB.new(application_name: config.app_name, logger: logger, client: client).tap do |eb|
+          eb.timeout = options[:timeout] * 60
+        end
+      end
+
+      def config
+        @config ||= JackAndTheElasticBeanstalk::Config.load(path: Pathname(options[:jack_dir]))
+      end
+
+      def service
+        @service ||= JackAndTheElasticBeanstalk::Service.new(source_dir: Pathname(options[:source_dir]), config: config, eb: eb, runner: runner, logger: logger)
+      end
+
+      def output_dir
+        Dir.mktmpdir do |dir|
+          yield Pathname(dir)
+        end
+      end
+
+      def try_process(name, is:)
+        if !is || is == name
+          yield(name)
+        end
+      end
+
+      def each_in_parallel(array)
+        Parallel.each_with_index(array, in_threads: array.size) do |a, index|
+          sleep index*5
+          yield a
+        end
+      end
+
+      def parse_env_args(args)
+        args.each.with_object({}) do |arg, hash|
+          k,v = arg.split("=", 2)
+          hash[k] = v
+        end
+      end
+    end
+
+    class_option :timeout, type: :numeric, default: 10, desc: "Minutes to timeout for each EB operation"
+    class_option :loglevel, type: :string, enum: ["info", "debug", "error"], default: "error", desc: "Loglevel"
+    class_option :jack_dir, type: :string, default: (Pathname.pwd + "jack").to_s, desc: "Directory to app.yml"
+    class_option :source_dir, type: :string, default: Pathname.pwd.to_s, desc: "Directory for source code"
+
+    desc "create CONFIGURATION GROUP ENV_VAR=VALUE...", "Create new group"
+    def create(configuration, group, *env_var_args)
+      processes = config.each_process(configuration).to_a
+      env_vars = parse_env_args(env_var_args)
+
+      output_dir do |base_path|
+        processes.each do |process, hash|
+          path = base_path + process
+          runner.stdout.puts "Staging for #{process}..."
+          service.stage(target_dir: path, process: process)
+        end
+
+        each_in_parallel(processes) do |process, hash|
+          runner.stdout.puts "Creating new environment for #{process}..."
+
+          path = base_path + process
+
+          service.eb_init(target_dir: path)
+          service.eb_create(target_dir: path, configuration: configuration, group: group, process: process, env_vars: env_vars)
+
+          if hash["type"] == "oneoff"
+            runner.stdout.puts "Scaling to 0 (#{process} is a oneoff process)"
+            env = service.each_environment(group: group).find {|_, p| p == process }.first
+            env.set_scale(0)
+            env.synchronize_update
+          end
+        end
+      end
+    end
+
+    desc "deploy GROUP", "Deploy to group"
+    def deploy(group)
+      envs = service.each_environment(group: group).to_a
+
+      prefix = Time.now.utc.iso8601
+
+      output_dir do |base_path|
+        archives = {}
+
+        envs.each do |_, process|
+          path = base_path + process
+          path.mkpath
+
+          runner.stdout.puts "Staging for #{process}..."
+          service.stage(target_dir: path, process: process)
+
+          name = "#{group}-#{prefix}-#{process}"
+          key = "#{config.app_name}/#{name}"
+
+          archive_path = base_path + "#{name}.zip"
+          service.archive(input_dir: path, output_path: archive_path)
+
+          archives[process] = [key, name, archive_path]
+        end
+
+        each_in_parallel(envs) do |_, process|
+          runner.stdout.puts "Deploying to #{process}..."
+
+          s3_key, label, archive_path = archives[process]
+
+          service.deploy(group: group,
+                         process: process,
+                         archive_path: archive_path,
+                         s3_key: s3_key,
+                         label: label)
+        end
+      end
+    end
+
+    desc "stage PROCESS OUTPUT_DIR", "Prepare application to deploy"
+    def stage(process, output_dir)
+      path = Pathname(output_dir)
+
+      if path.directory?
+        runner.stdout.puts "Deleting #{path}..."
+        path.rmtree
+      end
+
+      runner.stdout.puts "Staging for #{process} in #{path}..."
+
+      path.mkpath
+      service.eb_init target_dir: path
+      service.stage(target_dir: path, process: process)
+    end
+
+    desc "archive PROCESS OUTPUT_PATH", "Prepare application bundle at OUTPUT_PATH"
+    def archive(process, output_path)
+      zip_path = Pathname(output_path)
+
+      Dir.mktmpdir do |dir|
+        dir_path = Pathname(dir)
+
+        runner.stdout.puts "Staging for #{process}..."
+
+        dir_path.mkpath
+        service.stage(target_dir: dir_path, process: process)
+
+        runner.stdout.puts "Making application bundle to #{zip_path}..."
+
+        service.archive(input_dir: dir_path, output_path: zip_path)
+      end
+    end
+
+    desc "printenv GROUP [PROCESS]", "Print environment variables"
+    def printenv(group, process=nil)
+      service.each_environment(group: group) do |env, p|
+        try_process(p, is: process) do
+          puts "#{p} (#{env.environment_name}):"
+          env.env_vars.each do |key, value|
+            runner.stdout.puts "  #{key}=#{value}"
+          end
+        end
+      end
+    end
+
+    desc "setenv GROUP PROCESS name=var name= ...", "Set environment variables"
+    def setenv(group, *args)
+      process = if args.first !~ /=/
+                  args.shift
+                end
+
+      hash = parse_env_args(args)
+
+      logger.info("jeb::cli") { "Setting environment hash: #{hash.inspect}" }
+
+      envs = service.each_environment(group: group)
+      each_in_parallel(envs) do |env, p|
+        try_process(p, is: process) do
+          runner.stdout.puts "Updating #{p}'s environment variable..."
+          env.synchronize_update do
+            env.set_env_vars hash
+          end
+        end
+      end
+    end
+
+    desc "restart GROUP [PROCESS]", "Restart applications"
+    def restart(group, process=nil)
+      envs = service.each_environment(group: group)
+      each_in_parallel(envs) do |env, p|
+        try_process(p, is: process) do
+          runner.stdout.puts "Restarting #{p}..."
+          env.synchronize_update do
+            env.restart
+          end
+        end
+      end
+    end
+
+    desc "destroy GROUP [PROCESS]", "Terminate environments associated to GROUP"
+    def destroy(group, process=nil)
+      service.each_environment(group: group) do |env, p|
+        try_process p, is: process do
+          runner.stdout.puts "Destroying #{p}: #{env.environment_name}..."
+          env.destroy
+        end
+      end
+    end
+
+    desc "status GROUP [PROCESS]", "Print status of environments associated to GROUP"
+    def status(group, process=nil)
+      service.each_environment(group: group) do |env, p|
+        try_process p, is: process do
+          h = env.health
+          ih = h.instances_health
+          total = ih.no_data + ih.ok + ih.info + ih.warning + ih.degraded + ih.severe + ih.pending
+          runner.stdout.puts "#{p}: name=#{env.environment_name}, status=#{env.status}, health: #{h.health_status}, instances: #{total}, scale: #{env.scale}"
+        end
+      end
+    end
+
+    desc "exec GROUP command...", "Run oneoff command"
+    option :keep, type: :boolean, default: false, desc: "Keep started oneoff environment"
+    def exec(group, *command)
+      env = service.each_environment(group: group).find {|_, p| p == "oneoff" }&.first
+      if env
+        begin
+          env.synchronize_update do
+            runner.stdout.puts "Starting #{env.environment_name} for oneoff process..."
+            env.set_scale 1
+          end
+
+          output_dir do |path|
+            service.eb_init target_dir: path
+
+            runner.stdout.puts "Waiting for EB to complete deploy..."
+            sleep 30
+
+            start = Time.now
+
+            while true
+              dirs, _ = runner.capture3! "eb", "ssh", env.environment_name, "-c", "ls /var/app"
+
+              if dirs =~ /ondeck/
+                logger.info("jeb::cli") { "Waiting for deploy..." }
+              end
+              if dirs =~ /current/ && dirs !~ /ondeck/
+                break
+              end
+              if Time.now - start > options[:timeout]*60
+                raise "Timed out for waiting deploy..."
+              end
+
+              sleep 15
+            end
+
+            commandline = "cd /var/app/current && sudo -E -u webapp env PATH=$PATH #{command.join(' ')}"
+            out, err, status = runner.capture3 "eb", "ssh", env.environment_name, "-c", commandline
+
+            runner.stdout.print out
+            runner.stderr.print err
+
+            raise status.to_s unless status.success?
+          end
+        ensure
+          unless options[:keep]
+            env.synchronize_update do
+              runner.stdout.puts "Shutting down #{env.environment_name}..."
+              env.set_scale 0
+            end
+          end
+        end
+      else
+        runner.stdout.puts "Could not find environment associated to oneoff process..."
+      end
+    end
+
+    desc "scale GROUP PROCESS min max", "Scale instances"
+    def scale(group, process, min, max=min)
+      service.each_environment(group: group) do |env, p|
+        try_process p, is: process do
+          runner.stdout.puts "Scaling #{group} (#{env.environment_name}) to min=#{min}, max=#{max}..."
+          env.synchronize_update do
+            env.set_scale(min...max)
+          end
+        end
+      end
+    end
+
+    desc "list", "List groups"
+    def list
+      service.each_group do |group, envs|
+        runner.stdout.puts "#{group}: #{envs.map(&:environment_name).join(", ")}"
+      end
+    end
+
+    desc "synchronize", "Wait for update"
+    def synchronize(group)
+      service.each_environment(group: group) do |env, process|
+        if env.status != "Ready"
+          runner.stdout.puts "Waiting for #{process} (#{env.environment_name})..."
+          env.synchronize_update
+        end
+      end
+    end
+
+    desc "resources GROUP [PROCESS]", "Download resources associated to each environment"
+    def resources(group, process_name=nil)
+      resources = {}
+
+      service.each_environment(group: group) do |env, process|
+        try_process process, is: process_name do
+          ress = env.resources.environment_resources
+          resources[process] = {
+            environment_name: env.environment_name,
+            environment_id: env.environment_id,
+            auto_scaling_groups: ress.auto_scaling_groups.map(&:name),
+            instances: ress.instances.map(&:id),
+            launch_configurations: ress.launch_configurations.map(&:name),
+            load_balancers: ress.load_balancers.map(&:name),
+            queues: ress.queues.map(&:url).reject(&:empty?),
+            triggers: ress.triggers.map(&:name)
+          }
+        end
+      end
+
+      unless resources.empty?
+        runner.stdout.puts JSON.pretty_generate(resources)
+      end
+    end
+  end
+end

data/lib/jack_and_the_elastic_beanstalk/config.rb

@@ -0,0 +1,71 @@
+module JackAndTheElasticBeanstalk
+  class Config
+    attr_reader :app_hash
+    attr_reader :eb_configs
+
+    def initialize(app_hash:, eb_configs:)
+      @app_hash = app_hash
+      @eb_configs = eb_configs
+    end
+
+    def self.load(path:)
+      app_yml = path + "app.yml"
+      app_hash = YAML.load_file(app_yml.to_s)
+
+      eb_configs = path.children.each.with_object({}) do |file, acc|
+        relative_path = file.relative_path_from(path)
+        acc[relative_path] = file.read if file.extname == ".config"
+      end
+
+      Config.new(app_hash: app_hash, eb_configs: eb_configs)
+    end
+
+    def app_name
+      app_hash.dig("application", "name")
+    end
+
+    def region
+      app_hash.dig("application", "region")
+    end
+
+    def platform
+      app_hash.dig("application", "platform")
+    end
+
+    def configurations
+      app_hash["configurations"]
+    end
+
+    def s3_bucket
+      app_hash["s3_bucket"]
+    end
+
+    def processes(configuration)
+      configurations[configuration].select {|_, value| value["type"] }
+    end
+
+    def process_type(configuration, process)
+      processes(configuration)[process]["type"].to_s
+    end
+
+    def each_config
+      if block_given?
+        eb_configs.each do |path, content|
+          yield path, ERB.new(content).result
+        end
+      else
+        enum_for :each_config
+      end
+    end
+
+    def each_process(configuration)
+      if block_given?
+        processes(configuration).each do |key, hash|
+          yield key, hash
+        end
+      else
+        enum_for :each_process, configuration
+      end
+    end
+  end
+end

data/lib/jack_and_the_elastic_beanstalk/eb.rb

@@ -0,0 +1,240 @@
+module JackAndTheElasticBeanstalk
+  class EB
+    attr_reader :application_name
+    attr_reader :logger
+    attr_reader :client
+    attr_accessor :timeout
+
+    def initialize(application_name:, logger:, client:)
+      @application_name = application_name
+      @logger = logger
+      @client = client
+      @env_stack = []
+      @timeout = 600
+    end
+
+    def environments
+      @environments = client.describe_environments(application_name: application_name, include_deleted: false).environments.map {|env|
+        Environment.new(application_name: application_name,
+                        environment_name: env.environment_name,
+                        logger: logger,
+                        client: client).tap do |e|
+          e.timeout = timeout
+          e.data = env
+        end
+      }
+    end
+
+    def refresh
+      @environments = nil
+    end
+
+    def create_version(s3_bucket:, s3_key:, label:)
+      client.create_application_version(application_name: application_name,
+                                        description: label,
+                                        version_label: label,
+                                        source_bundle: {
+                                          s3_bucket: s3_bucket,
+                                          s3_key: s3_key,
+                                        },
+                                        process: true)
+    end
+
+    class Environment
+      attr_reader :application_name
+      attr_reader :logger
+      attr_reader :client
+      attr_reader :environment_name
+      attr_accessor :timeout
+
+      def initialize(application_name:, logger:, client:, environment_name:)
+        @application_name = application_name
+        @logger = logger
+        @client = client
+        @environment_name = environment_name
+        @timeout = 600
+      end
+
+      def refresh
+        @data = nil
+        @configuration_setting = nil
+      end
+
+      def data=(v)
+        @data = v
+      end
+
+      def data
+        @data ||= client.describe_environments(application_name: application_name).environments.find {|env|
+          env.environment_name == environment_name
+        }
+      end
+
+      def configuration_setting
+        @configuration_setting ||= client.describe_configuration_settings(application_name: application_name, environment_name: environment_name).configuration_settings.first
+      end
+
+      def env_vars
+        configuration_setting.option_settings.each.with_object({}) do |option, hash|
+          if option.namespace == "aws:elasticbeanstalk:application:environment"
+            hash[option.option_name] = option.value
+          end
+        end
+      end
+
+      def set_env_vars(env)
+        need_update = env.all? {|key, value|
+          if value
+            env_vars[key] == value
+          else
+            !env_vars.key?(key)
+          end
+        }
+
+        if need_update
+          logger.info("jeb::eb") { "Env vars looks like identical; skip" }
+        else
+          logger.info("jeb::eb") { "Updating environment variables" }
+
+          options_to_update = []
+          options_to_remove = []
+
+          env.each do |key, value|
+            if value
+              options_to_update << {
+                namespace: "aws:elasticbeanstalk:application:environment",
+                option_name: key.to_s,
+                value: value.to_s
+              }
+            else
+              options_to_remove << {
+                namespace: "aws:elasticbeanstalk:application:environment",
+                option_name: key.to_s
+              }
+            end
+          end
+
+          client.update_environment(application_name: application_name,
+                                    environment_name: environment_name,
+                                    option_settings: options_to_update,
+                                    options_to_remove: options_to_remove)
+
+          refresh
+        end
+      end
+
+      def synchronize_update(timeout: self.timeout)
+        logger.info("jeb::eb") { "Synchronizing update started... (timeout = #{timeout})" }
+
+        yield if block_given?
+
+        start = Time.now
+        wait = 1
+
+        while true
+          refresh
+          st = status
+
+          logger.info("jeb::eb") { "#{environment_name}:: status=#{st}" }
+
+          case st
+          when "Ready"
+            break
+          when "Updating", "Launching", "Aborting"
+            # ok
+          else
+            raise "Unexpected status: #{st}"
+          end
+
+          if Time.now - start > timeout
+            raise "Timeout exceeded"
+          end
+
+          sleep wait
+          wait = [wait*2, 30].min
+        end
+
+        logger.info("jeb::eb") { "Synchronized in #{(Time.now - start).to_i} seconds" }
+      end
+
+      def scale
+        option_settings = configuration_setting.option_settings
+
+        min = option_settings.find {|option| option.namespace == "aws:autoscaling:asg" && option.option_name == "MinSize" }.value.to_i
+        max = option_settings.find {|option| option.namespace == "aws:autoscaling:asg" && option.option_name == "MaxSize" }.value.to_i
+
+        min...max
+      end
+
+      def status
+        data.status
+      end
+
+      def set_scale(scale)
+        if scale.is_a?(Integer)
+          scale = scale...scale
+        end
+
+        if self.scale == scale
+          logger.info("jeb::eb") { "New scale is identical to current scale; skip" }
+        else
+          logger.info("jeb::eb") { "Scaling to #{scale}" }
+
+          client.update_environment(application_name: application_name,
+                                    environment_name: environment_name,
+                                    option_settings: [
+                                      {
+                                        namespace: "aws:autoscaling:asg",
+                                        option_name: "MinSize",
+                                        value: scale.begin.to_s
+                                      },
+                                      {
+                                        namespace: "aws:autoscaling:asg",
+                                        option_name: "MaxSize",
+                                        value: scale.end.to_s
+                                      }
+                                    ])
+
+          refresh
+        end
+      end
+
+      def environment_id
+        data.environment_id
+      end
+
+      def destroy
+        logger.info("jeb::eb") { "Terminating #{environment_name}..." }
+        client.terminate_environment(environment_id: environment_id)
+      end
+
+      def health
+        logger.info("jeb::eb") { "Downloading health data on #{environment_name}..." }
+
+        client.describe_environment_health(environment_id: environment_id, attribute_names: ["All"])
+      end
+
+      def resources
+        logger.info("jeb::eb") { "Downloading resources on #{environment_name}..."}
+
+        client.describe_environment_resources(environment_id: environment_id)
+      end
+
+      def restart
+        logger.info("jeb::eb") { "Restarting #{environment_name}..." }
+        client.restart_app_server(environment_id: environment_id)
+      end
+
+      def deploy(label:)
+        client.update_environment(environment_id: environment_id,
+                                  version_label: label)
+      end
+
+      def ensure_version!(expected_label:)
+        unless data.version_label == expected_label
+          raise "Unexpected version label: expected=#{expected_label}, actual=#{data.version_label}"
+        end
+      end
+    end
+  end
+end

data/lib/jack_and_the_elastic_beanstalk/runner.rb

@@ -0,0 +1,73 @@
+module JackAndTheElasticBeanstalk
+  class Runner
+    attr_reader :stdin
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :logger
+
+    def initialize(stdin:, stdout:, stderr:, logger:)
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @paths = [Pathname.pwd]
+      @logger = logger
+    end
+
+    def paths
+      id = "#{inspect}:paths".to_sym
+
+      unless Thread.current[id]
+        Thread.current[id] = @paths.dup
+      end
+
+      Thread.current[id]
+    end
+
+    def chdir(dir)
+      paths.push dir
+      yield
+    ensure
+      paths.pop
+    end
+
+    def pwd
+      paths.last
+    end
+
+    def each_line(string, prefix: nil)
+      Array(string).flat_map {|s| s.split(/\n/) }.each do |line|
+        if prefix
+          yield "#{prefix}: #{line}"
+        else
+          yield line
+        end
+      end
+    end
+
+    def capture3(*commands, options: {}, env: {})
+      logger.debug("jeb") { commands.inspect }
+
+      Open3.capture3(env, *commands, { chdir: pwd.to_s }.merge(options)).tap do |out, err, status|
+        logger.debug("jeb") { status.inspect }
+
+        each_line(out, prefix: "stdout") do |line|
+          logger.debug("jeb") { line }
+        end
+
+        each_line(err, prefix: "stderr") do |line|
+          logger.debug("jeb") { line }
+        end
+      end
+    end
+
+    def capture3!(*commands, options: {}, env: {})
+      out, err, status = capture3(*commands, options: options, env: env)
+
+      unless status.success?
+        raise "Faiiled to execute command: #{commands.inspect}"
+      end
+
+      [out, err]
+    end
+  end
+end

data/lib/jack_and_the_elastic_beanstalk/service.rb

@@ -0,0 +1,193 @@
+module JackAndTheElasticBeanstalk
+  class Service
+    attr_reader :config
+    attr_reader :source_dir
+    attr_reader :eb
+    attr_reader :runner
+    attr_reader :logger
+
+    def initialize(config:, source_dir:, eb:, runner:, logger:)
+      @config = config
+      @source_dir = source_dir
+      @eb = eb
+      @runner = runner
+      @logger = logger
+    end
+
+    def eb_init(target_dir:)
+      runner.chdir target_dir do
+        runner.capture3!("eb", "init", config.app_name, "-r", config.region, "-p", config.platform)
+      end
+    end
+
+    def eb_deploy(target_dir:, group:, process:)
+      runner.chdir target_dir do
+        runner.capture3!("eb", "deploy", env_name(group: group, process: process), "--nohang")
+      end
+
+      env = eb.environments.find {|env| env.environment_name == env_name(group: group, process: process) }
+      env.synchronize_update
+    end
+
+    def eb_create(target_dir:, configuration:, group:, process:, env_vars:)
+      if eb.environments.none? {|env| env.environment_name == env_name(group: group, process: process) }
+        logger.info("jeb::service") { "Creating eb environment for #{process} from #{target_dir}..." }
+
+        commandline = ["eb", "create", env_name(group: group, process: process), "--nohang", "--scale", "1"]
+
+        hash = config.processes(configuration)[process]
+
+        commandline.concat(["-t", "worker"]) if config.process_type(configuration, process) == "worker"
+        commandline.concat(["--region", hash["region"] || config.region])
+        commandline.concat(["--platform", hash["platform"] || config.platform])
+        commandline.concat(["--instance_profile", hash["instance_profile"]]) if hash["instance_profile"]
+        commandline.concat(["--keyname", hash["keyname"]]) if hash["keyname"]
+        commandline.concat(["--instance_type", hash["instance_type"]]) if hash["instance_type"]
+        commandline.concat(["--service-role", hash["service_role"]]) if hash["service_role"]
+
+        if hash["tags"]&.any?
+          commandline.concat(["--tags", hash["tags"].each.with_object([]) do |(key, value), acc|
+            acc << "#{key}=#{value}"
+          end.concat(",")])
+        end
+
+        if hash["vpc"]
+          vpc = hash["vpc"]
+
+          commandline.concat(["--vpc", "--vpc.id", vpc["id"]])
+          commandline.concat(["--vpc.ec2subnets", vpc["ec2subnets"].join(",")]) if vpc["ec2subnets"]&.any?
+          commandline.concat(["--vpc.elbpublic"]) if vpc["elbpublic"]
+          commandline.concat(["--vpc.elbsubnets", vpc["elbsubnets"].join(",")]) if vpc["elbsubnets"]&.any?
+          commandline.concat(["--vpc.publicip"]) if vpc["publicip"]
+          commandline.concat(["--vpc.securitygroups", vpc["securitygroups"].join(",")]) if vpc["securitygroups"]&.any?
+        end
+
+        unless env_vars.empty?
+          vars = env_vars.to_a.map {|(k, v)| "#{k}=#{v}" }.join(",")
+          commandline.concat(["--envvars", vars])
+        end
+
+        runner.chdir target_dir do
+          runner.capture3!(*commandline)
+        end
+
+        eb.refresh
+        env = eb.environments.find {|env| env.environment_name == env_name(group: group, process: process) }
+        env.synchronize_update
+      else
+        logger.info("jeb::service") { "Environment #{env_name(group:group, process: process)} already exists..." }
+      end
+    end
+
+    def env_name(group:, process:)
+      "jeb-#{group}-#{process}"
+    end
+
+    def stage(target_dir:, process:)
+      logger.info("jeb::service") { "Staging files in #{target_dir} for #{process}" }
+
+      ENV["JEB_PROCESS"] = process
+
+      export_files(dest: target_dir)
+
+      eb_extensions = target_dir + ".ebextensions"
+      eb_extensions.mkpath
+      config.each_config do |path, content|
+        logger.debug("jeb::service") { "Writing #{path} ..." }
+        (eb_extensions + path).write content
+      end
+    ensure
+      ENV.delete("JEB_PROCESS")
+    end
+
+    def archive(input_dir:, output_path:)
+      paths = Pathname.glob(input_dir + "**/*", File::FNM_DOTMATCH).select(&:file?)
+
+      Zip::File.open(output_path.to_s, Zip::File::CREATE) do |zip|
+        paths.each do |path|
+          zip.add(path.relative_path_from(input_dir).to_s, path.to_s)
+        end
+      end
+    end
+
+    def export_files(dest:)
+      files = runner.chdir(source_dir) do
+        runner.capture3!("git", "ls-files", "-z").first.split("\x0")
+      end
+
+      files.each do |f|
+        logger.debug("jeb::service") { "Copying #{f} ..."}
+
+        source_path = source_dir + f
+        target_path = dest + f
+
+        unless target_path.parent.directory?
+          target_path.parent.mkpath
+        end
+
+        FileUtils.copy(source_path.to_s, target_path.to_s)
+      end
+    end
+
+    def upload(archive_path:, name:)
+      logger.debug("jeb::service") { "Uploading #{archive_path} to #{config.s3_bucket}/#{name}..." }
+      s3 = Aws::S3::Client.new(region: config.region)
+      archive_path.open do |io|
+        s3.put_object(bucket: config.s3_bucket, key: name, body: io)
+      end
+    end
+
+    def deploy(group:, process:, archive_path:, s3_key:, label:)
+      upload(archive_path: archive_path, name: s3_key)
+      eb.create_version(s3_bucket: config.s3_bucket, s3_key: s3_key, label: label)
+
+      eb.environments.find {|env| env.environment_name == env_name(group: group, process: process) }.try do |env|
+        env.synchronize_update do
+          env.deploy(label: label)
+        end
+
+        env.ensure_version!(expected_label: label)
+      end
+    end
+
+    def destroy(group:)
+      logger.info("jeb::service") { "Destroying #{group} ..." }
+
+      each_environment(group: group) do |env, _|
+        env.destroy
+      end
+    end
+
+    def each_environment(group:)
+      if block_given?
+        regexp = /\Ajeb-#{group}-([^\-]+)\Z/
+
+        eb.environments.each do |env|
+          if env.environment_name =~ regexp
+            yield env, $1
+          end
+        end
+      else
+        enum_for :each_environment, group: group
+      end
+    end
+
+    def each_group
+      if block_given?
+        regexp = /\Ajeb-(.+)-([^\-]+)\Z/
+
+        eb.environments.group_by {|env|
+          if env.environment_name =~ regexp
+            $1
+          end
+        }.each do |group, envs|
+          if group
+            yield group, envs
+          end
+        end
+      else
+        enum_for :each_group
+      end
+    end
+  end
+end

data/lib/jack_and_the_elastic_beanstalk/version.rb

@@ -0,0 +1,3 @@
+module JackAndTheElasticBeanstalk
+  VERSION = "0.1.0.pre"
+end

data/lib/jack_and_the_elastic_beanstalk.rb

@@ -0,0 +1,24 @@
+require "jack_and_the_elastic_beanstalk/version"
+
+require "optparse"
+require "pathname"
+require 'dotenv'
+require "rainbow"
+require "erb"
+require "yaml"
+require "open3"
+require "logger"
+require "tmpdir"
+require "pp"
+require "aws-sdk"
+require "thor"
+require "parallel"
+require "active_support"
+require "active_support/core_ext"
+require "zip"
+
+require "jack_and_the_elastic_beanstalk/eb"
+require "jack_and_the_elastic_beanstalk/config"
+require "jack_and_the_elastic_beanstalk/runner"
+require "jack_and_the_elastic_beanstalk/service"
+require "jack_and_the_elastic_beanstalk/cli"

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: jack_and_the_elastic_beanstalk
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+platform: ruby
+authors:
+- Soutaro Matsumoto
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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: rainbow
+  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: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: 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'
+description: Jack and the Elastic Beanstalk.
+email:
+- matsumoto@soutaro.com
+executables:
+- jeb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/jeb
+- jack_and_the_elastic_beanstalk.gemspec
+- lib/jack_and_the_elastic_beanstalk.rb
+- lib/jack_and_the_elastic_beanstalk/cli.rb
+- lib/jack_and_the_elastic_beanstalk/config.rb
+- lib/jack_and_the_elastic_beanstalk/eb.rb
+- lib/jack_and_the_elastic_beanstalk/runner.rb
+- lib/jack_and_the_elastic_beanstalk/service.rb
+- lib/jack_and_the_elastic_beanstalk/version.rb
+homepage: https://github.com/sideci/jack_and_the_elastic_beanstalk
+licenses: []
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Jack and the Elastic Beanstalk.
+test_files: []