wrapbox 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c76da62eee815c3ab4d57a567a8a83810d9b7f20
+  data.tar.gz: 4c3df8f6ce34d0ae48f476d32e57d85170ce0028
+SHA512:
+  metadata.gz: c2b799ee4e165c93dcf829659e513d610ad07f666377b8c3631c63209175bee00f7431b233dec3615cbd6dcba509895b4f4f7fa1e21b6b5174e7eb68d1673b22
+  data.tar.gz: 600bd6d4359e2534bf0c047621d61b2a7df7d5bcbe9143eb84e465b081f6714744027c9cf2ff989615c468cb6893b664b21b3aa6fb61322f558e71cc1048e0f1

data/.dockerignore

@@ -0,0 +1,12 @@
+.bundle
+.yardoc
+Gemfile.lock
+_yardoc
+coverage
+doc
+pkg
+spec/reports
+tmp
+.travis.yml
+
+.envrc

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

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

data/Dockerfile

@@ -0,0 +1,7 @@
+FROM ruby:alpine
+
+RUN apk add --no-cache git
+WORKDIR /app
+COPY . /app/
+
+RUN bundle install

data/Gemfile

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

data/README.md

@@ -0,0 +1,117 @@
+# Wrapbox
+
+Wrapbox runs Ruby method or shell command in a container (ECS, docker).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wrapbox'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wrapbox
+
+## Usage
+
+Write config.yml
+
+```yaml
+default:
+  cluster: ecsr-test
+  runner: ecs
+  region: ap-northeast-1
+  container_definition:
+    image: joker1007/wrapbox
+    cpu: 512
+    memory: 1024
+    essential: true
+
+docker:
+  runner: docker
+  rm: true
+  container_definition:
+    image: joker1007/wrapbox
+    cpu: 512
+    memory: 1024
+```
+
+```ruby
+Wrapbox.configure do |c|
+  c.load_yaml(File.expand_path("../config.yml", __FILE__))
+end
+
+# runs TestJob#perform in ECS container
+Wrapbox.run("TestJob", :perform, ["arg1", ["arg2", "arg3"]], environments: [{name: "RAILS_ENV", value: "development"}]) # use default config
+# runs TestJob#perform in local docker container (Use docker cli)
+Wrapbox.run("TestJob", :perform, ["arg1", ["arg2", "arg3"]], config_name: :docker, environments: [{name: "RAILS_ENV", value: "development"}]) # use docker config
+
+# runs ls . command in ECS container
+Wrapbox.run_cmd("ls", ".", environments: [{name: "RAILS_ENV", value: "development"}])
+
+# runs ls . command in local docker container
+Wrapbox.run_cmd("ls", ".", config_name: :docker, environments: [{name: "RAILS_ENV", value: "development"}])
+```
+
+## Config
+
+### Common
+
+| name   | desc              |
+| ------ | ----------------- |
+| runner | "ecs" or "docker" |
+
+### for ECS
+
+| name                             | desc                                                                                                        |
+| --------------------             | ------------------------------------------------                                                            |
+| cluster                          | target ECS cluster name                                                                                     |
+| region                           | region of ECS cluster                                                                                       |
+| container_definition             | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| additional_container_definitions | Container definitions for sub containers                                                                    |
+| task_role_arn                    | see. http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html                         |
+
+### for docker
+| name                 | desc                                                        |
+| -------------------- | ----------------------------------------------------------- |
+| container_definition | only use `image`, `cpu`, `memory`, and `memory_reservation` |
+| rm                   | If true, add `--rm` to cmd options                          |
+| use_sudo             | If true, invoke `sudo docker` command                       |
+
+## API
+
+#### `run(class_name, method_name, args, container_definition_overrides: {}, environments: [], task_role_arn: nil, cluster: nil, timeout: 3600 * 24, launch_timeout: 60 * 10, launch_retry: 10)`
+
+#### `run_cmd(*cmd, container_definition_overrides: {}, environments: [], task_role_arn: nil, cluster: nil, timeout: 3600 * 24, launch_timeout: 60 * 10, launch_retry: 10)`
+
+following options is only for ECS.
+
+- task_role_arn
+- cluster
+- timeout
+- launch_timeout
+- launch_retry
+
+If Wrapbox cannot launch task in `launch_timeout` seconds, it puts custom metric data to CloudWatch.
+Custom metric data is `wrapbox/WaitingTaskCount` that has `ClusterName` dimension.
+And, it retry launching until retry count reach `launch_retry`.
+
+After task exited, Wrapbox checks main container exit code.
+If exit code is not 0, Wrapbox raise error.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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/reproio/wrapbox.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+load "wrapbox/tasks/run.rake"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require_relative "./spec/test_job"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wrapbox"
+
+# 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/lib/wrapbox/config_repository.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+module Wrapbox
+  class ConfigRepository
+    def initialize
+      @configs = {}
+    end
+
+    def load_yaml(yaml_file)
+      configs = YAML.load(ERB.new(File.read(yaml_file)).result)
+      configs.each do |name, configuration|
+        load_config(name, configuration.merge("name" => name))
+      end
+    end
+
+    def load_config(name, configuration)
+      @configs[name.to_sym] = Configuration.load_config(configuration)
+    end
+
+    def default
+      @configs[:default]
+    end
+
+    def get(name)
+      name ? @configs[name.to_sym] : default
+    end
+    alias_method(:[], :get)
+  end
+end

data/lib/wrapbox/configuration.rb

@@ -0,0 +1,50 @@
+require "active_support/core_ext/hash"
+require "active_support/core_ext/string"
+
+module Wrapbox
+  Configuration = Struct.new(
+    :name,
+    :runner,
+    :cluster,
+    :region,
+    :container_definition,
+    :additional_container_definitions,
+    :task_role_arn,
+    :use_sudo,
+    :rm
+  ) do
+    def self.load_config(config)
+      new(
+        config["name"],
+        config["runner"] ? config["runner"].to_sym : :docker,
+        config["cluster"],
+        config["region"],
+        config["container_definition"].deep_symbolize_keys,
+        config["additional_container_definitions"] || [],
+        config["task_role_arn"],
+        config["use_sudo"].nil? ? false : config["use_sudo"],
+        config["rm"].nil? ? false : config["rm"]
+      )
+    end
+
+    AVAILABLE_RUNNERS = %i(docker ecs)
+
+    def initialize(*args)
+      super
+      raise "#{runner} is unsupported runner" unless AVAILABLE_RUNNERS.include?(runner)
+      require "wrapbox/runner/#{runner}"
+    end
+
+    def build_runner
+      Wrapbox::Runner.const_get(runner.to_s.camelcase).new(to_h)
+    end
+
+    def run(class_name, method_name, args, **options)
+      build_runner.run(class_name, method_name, args, **options)
+    end
+
+    def run_cmd(*cmd, **options)
+      build_runner.run_cmd(*cmd, **options)
+    end
+  end
+end

data/lib/wrapbox/job.rb

@@ -0,0 +1,13 @@
+require "multi_json"
+
+module Wrapbox
+  module Job
+    def self.perform
+      klass = ENV[CLASS_NAME_ENV].constantize
+      method_name = ENV[METHOD_NAME_ENV].to_sym
+      args = MultiJson.load(ENV[METHOD_ARGS_ENV])
+
+      klass.new.send(method_name, *args)
+    end
+  end
+end

data/lib/wrapbox/runner/docker.rb

@@ -0,0 +1,95 @@
+require "open3"
+require "multi_json"
+
+module Wrapbox
+  module Runner
+    class Docker
+      class ExecutionError < StandardError; end
+
+      attr_reader \
+        :name,
+        :container_definition,
+        :rm,
+        :use_sudo
+
+      def initialize(options)
+        @name = options[:name]
+        @container_definition = options[:container_definition]
+        @rm = options[:rm]
+        @use_sudo = options[:use_sudo]
+      end
+
+      def run(class_name, method_name, args, container_definition_overrides: {}, environments: [])
+        definition = container_definition
+          .merge(container_definition_overrides)
+
+        cmdopt = build_cmdopt(definition)
+        cmdopt.concat(base_environments(class_name, method_name, args))
+        cmdopt.concat(extract_environments(environments))
+        cmdopt.concat([definition[:image], "bundle", "exec", "rake", "wrapbox:run"])
+
+        exec_docker(*cmdopt)
+      end
+
+      def run_cmd(*cmd,  container_definition_overrides: {}, environments: [])
+        definition = container_definition
+          .merge(container_definition_overrides)
+
+        cmdopt = build_cmdopt(definition)
+        cmdopt.concat(extract_environments(environments))
+        cmdopt.concat([definition[:image], *cmd])
+
+        exec_docker(*cmdopt)
+      end
+
+      private
+
+      def build_cmdopt(definition)
+        cmdopt = ["run"]
+        cmdopt.concat(["--rm"]) if rm
+        cmdopt.concat(["--cpu-shares", definition[:cpu].to_s]) if definition[:cpu]
+        cmdopt.concat(["--memory", "#{definition[:memory]}m"]) if definition[:memory]
+        cmdopt.concat(["--memory-reservation", "#{definition[:memory_reservation]}m"]) if definition[:memory_reservation]
+        cmdopt
+      end
+
+      def base_environments(class_name, method_name, args)
+        ["-e", "#{CLASS_NAME_ENV}=#{class_name}", "-e", "#{METHOD_NAME_ENV}=#{method_name}", "-e", "#{METHOD_ARGS_ENV}=#{MultiJson.dump(args)}"]
+      end
+
+      def extract_environments(environments)
+        environments.flat_map do |e|
+          ["-e", "#{e[:name]}=#{e[:value]}"]
+        end
+      end
+
+      def exec_docker(*args)
+        cmd = use_sudo ? "sudo docker" : "docker"
+
+        result = Open3.popen3(cmd, *args) do |stdin, stdout, stderr, wait_thr|
+          stdin.close_write
+          begin
+            loop do
+              rs, _ = IO.select([stdout, stderr])
+              rs.each do |io|
+                io.each do |line|
+                  next if line.nil? || line.empty?
+                  if io == stdout
+                    $stdout.puts(line)
+                  else
+                    $stderr.puts(line)
+                  end
+                end
+              end
+              break if stdout.eof? && stderr.eof?
+            end
+          rescue EOFError
+          end
+          wait_thr.value
+        end
+
+        raise ExecutionError, "exit_code=#{result.exitstatus}" unless result.success?
+      end
+    end
+  end
+end

data/lib/wrapbox/runner/ecs.rb

@@ -0,0 +1,202 @@
+require "aws-sdk"
+require "multi_json"
+
+module Wrapbox
+  module Runner
+    class Ecs
+      class ExecutionError < StandardError; end
+
+      attr_reader \
+        :name,
+        :cluster,
+        :region,
+        :container_definition,
+        :additional_container_definitions,
+        :task_role_arn
+
+      def initialize(options)
+        @name = options[:name]
+        @cluster = options[:cluster]
+        @region = options[:region]
+        @container_definition = options[:container_definition]
+        @additional_container_definitions = options[:additional_container_definitions]
+        @task_role_arn = options[:task_role_arn]
+      end
+
+      def run(class_name, method_name, args, container_definition_overrides: {}, environments: [], task_role_arn: nil, cluster: nil, timeout: 3600 * 24, launch_timeout: 60 * 10, launch_retry: 10)
+        task_definition = register_task_definition(container_definition_overrides)
+        run_task(
+          task_definition.task_definition_arn, class_name, method_name, args,
+          command: ["bundle", "exec", "rake", "wrapbox:run"],
+          environments: environments,
+          task_role_arn: task_role_arn,
+          cluster: cluster,
+          timeout: timeout,
+          launch_timeout: launch_timeout,
+          launch_retry: launch_retry,
+        )
+      end
+
+      def run_cmd(*cmd, container_definition_overrides: {}, environments: [], task_role_arn: nil, cluster: nil, timeout: 3600 * 24, launch_timeout: 60 * 10, launch_retry: 10)
+        task_definition = register_task_definition(container_definition_overrides)
+
+        run_task(
+          task_definition.task_definition_arn, nil, nil, nil,
+          command: cmd,
+          environments: environments,
+          task_role_arn: task_role_arn,
+          cluster: cluster,
+          timeout: timeout,
+          launch_timeout: launch_timeout,
+          launch_retry: launch_retry,
+        )
+      end
+
+      def run_task(task_definition_arn, class_name, method_name, args, command:, environments: [], task_role_arn: nil, cluster: nil, timeout: 3600 * 24, launch_timeout: 60 * 10, launch_retry: 10)
+        cl = cluster || self.cluster
+        args = Array(args)
+
+        task = client
+          .run_task(build_run_task_options(class_name, method_name, args, command, environments, cluster, task_definition_arn, task_role_arn))
+          .tasks[0]
+
+        launch_try_count = 0
+        begin
+          launched_at = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+          client.wait_until(:tasks_running, cluster: cl, tasks: [task.task_arn]) do |w|
+            if launch_timeout
+              w.max_attempts = nil
+              w.before_wait do
+                throw :failure if Process.clock_gettime(Process::CLOCK_MONOTONIC, :second) - launched_at > launch_timeout
+              end
+            end
+          end
+        rescue Aws::Waiters::Errors::TooManyAttemptsError
+          if launch_try_count >= launch_retry
+            client.stop_task(
+              cluster: cl,
+              task: task.task_arn,
+              reason: "launch timeout"
+            )
+            raise
+          else
+            put_waiting_task_count_metric(cl)
+            launch_try_count += 1
+            retry
+          end
+        rescue Aws::Waiters::Errors::WaiterFailed
+        end
+
+        begin
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+          client.wait_until(:tasks_stopped, cluster: cl, tasks: [task.task_arn]) do |w|
+            if timeout
+              w.max_attempts = nil
+              w.before_wait do
+                throw :failure if Process.clock_gettime(Process::CLOCK_MONOTONIC, :second) - started_at > timeout
+              end
+            end
+          end
+        rescue Aws::Waiters::Errors::TooManyAttemptsError
+          client.stop_task({
+            cluster: cluster || self.cluster,
+            task: task.task_arn,
+            reason: "process timeout",
+          })
+        end
+
+        task = client.describe_tasks(cluster: cl, tasks: [task.task_arn]).tasks[0]
+        container = task.containers.find { |c| c.name = task_definition_name }
+        unless container.exit_code == 0
+          raise ExecutionError, "Container #{task_definition_name} is failed. exit_code=#{container.exit_code}"
+        end
+      end
+
+      private
+
+      def task_definition_name
+        "wrapbox_#{name}"
+      end
+
+      def register_task_definition(container_definition_overrides)
+        definition = container_definition
+          .merge(container_definition_overrides)
+          .merge(name: task_definition_name)
+        container_definitions = [definition, *additional_container_definitions]
+        client.register_task_definition({
+          family: task_definition_name,
+          container_definitions: container_definitions,
+        }).task_definition
+      end
+
+      def client
+        return @client if @client
+
+        options = {}
+        options[:region] = region if region
+        @client = Aws::ECS::Client.new(options)
+      end
+
+      def cloud_watch_client
+        return @cloud_watch_client if @cloud_watch_client
+
+        options = {}
+        options[:region] = region if region
+        @cloud_watch_client = Aws::CloudWatch::Client.new
+      end
+
+      def put_waiting_task_count_metric(cluster)
+        cloud_watch_client.put_metric_data(
+          namespace: "wrapbox",
+          metric_data: [
+            metric_name: "WaitingTaskCount",
+            dimensions: [
+              {
+                name: "ClusterName",
+                value: cluster || self.cluster,
+              },
+            ],
+            value: 1.0,
+            unit: "Count",
+          ]
+        )
+      end
+
+      def build_run_task_options(class_name, method_name, args, command, environments, cluster, task_definition_arn, task_role_arn)
+        env = environments
+        env += [
+          {
+            name: CLASS_NAME_ENV,
+            value: class_name.to_s,
+          },
+          {
+            name: METHOD_NAME_ENV,
+            value: method_name.to_s,
+          },
+          {
+            name: METHOD_ARGS_ENV,
+            value: MultiJson.dump(args),
+          },
+        ] if class_name && method_name && args
+        overrides = {
+          container_overrides: [
+            {
+              name: task_definition_name,
+              command: command,
+              environment: env,
+            },
+          ],
+        }
+        role_arn = task_role_arn || self.task_role_arn
+        overrides[:task_role_arn] = role_arn if role_arn
+
+        {
+          cluster: cluster || self.cluster,
+          task_definition: task_definition_arn,
+          overrides: overrides,
+          started_by: "wrapbox-#{Wrapbox::VERSION}",
+        }
+      end
+    end
+  end
+end

data/lib/wrapbox/tasks/run.rake

@@ -0,0 +1,14 @@
+require "wrapbox"
+
+namespace :wrapbox do
+  desc "Run Wrapbox"
+  task :run do
+    Rake::Task["environment"].invoke if defined?(Rails)
+
+    if ENV[Wrapbox::CLASS_NAME_ENV] && ENV[Wrapbox::METHOD_NAME_ENV] && ENV[Wrapbox::METHOD_ARGS_ENV]
+      Wrapbox::Job.perform
+    else
+      raise "Wrapbox ENVs are not found"
+    end
+  end
+end

data/lib/wrapbox/version.rb

@@ -0,0 +1,3 @@
+module Wrapbox
+  VERSION = "0.1.0"
+end

data/lib/wrapbox.rb

@@ -0,0 +1,31 @@
+module Wrapbox
+  CLASS_NAME_ENV = "WRAPBOX_CLASS_NAME".freeze
+  METHOD_NAME_ENV = "WRAPBOX_METHOD_NAME".freeze
+  METHOD_ARGS_ENV = "WRAPBOX_METHOD_ARGS".freeze
+
+  class << self
+    def configs
+      @configs ||= ConfigRepository.new
+    end
+
+    def configure
+      yield configs
+    end
+
+    def run(*args, config_name: nil, **options)
+      config = @configs.get(config_name)
+      config.run(*args, **options)
+    end
+
+    def run_cmd(*args, config_name: nil, **options)
+      config = @configs.get(config_name)
+      config.run_cmd(*args, **options)
+    end
+  end
+end
+
+require "wrapbox/version"
+
+require "wrapbox/config_repository"
+require "wrapbox/configuration"
+require "wrapbox/job"

data/wrapbox.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wrapbox/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wrapbox"
+  spec.version       = Wrapbox::VERSION
+  spec.authors       = ["joker1007"]
+  spec.email         = ["kakyoin.hierophant@gmail.com"]
+
+  spec.summary       = %q{Ruby method runner on AWS ECS}
+  spec.description   = %q{Ruby method runner on AWS ECS}
+  spec.homepage      = ""
+
+  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_runtime_dependency "aws-sdk", "~> 2.4"
+  spec.add_runtime_dependency "activesupport", ">= 4"
+  spec.add_runtime_dependency "multi_json"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "tapp"
+  spec.add_development_dependency "tapp-awesome_print"
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: wrapbox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- joker1007
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapp-awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby method runner on AWS ECS
+email:
+- kakyoin.hierophant@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".dockerignore"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Dockerfile
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/wrapbox.rb
+- lib/wrapbox/config_repository.rb
+- lib/wrapbox/configuration.rb
+- lib/wrapbox/job.rb
+- lib/wrapbox/runner/docker.rb
+- lib/wrapbox/runner/ecs.rb
+- lib/wrapbox/tasks/run.rake
+- lib/wrapbox/version.rb
+- wrapbox.gemspec
+homepage: ''
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Ruby method runner on AWS ECS
+test_files: []