dockage 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2417e272201a9a36b24260d7e8b168379718e9e3
+  data.tar.gz: eb9a331706bfe55962f6dcc90a265221eec0367b
+SHA512:
+  metadata.gz: 46ab38e61c9d00034b60c539306f22c6d57d1921722f92ba2b17cb1049016005e94572894a255acbb8a83bc8633a511abb6c40b1248dcbd52624fb2414ec6bfe
+  data.tar.gz: 7cc2aa98103a73399c8c8935cc3a9c134e05018fab01f9af29b45b0c3e7fcf9ceda1f24f2c553da19b362d73c63ffa9044562dcb543685c3efa4cc1501caa663

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.swp
+mkmf.log
+vendor/bundler

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1.3
+script:
+  - bundle exec rspec spec

data/Gemfile

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

data/LICENSE.md

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

data/README.md

@@ -0,0 +1,31 @@
+# Dockage [![Dependency Status](https://gemnasium.com/kressh/dockage.svg)](https://gemnasium.com/kressh/dockage) [![Code Climate](https://codeclimate.com/github/kressh/dockage/badges/gpa.svg)](https://codeclimate.com/github/kressh/dockage) [![Build Status](https://travis-ci.org/kressh/dockage.svg?branch=master)](https://travis-ci.org/kressh/dockage)
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dockage'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dockage
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/dockage/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/dockage

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# Exit cleanly from an early interrupt
+Signal.trap('INT') { exit 1 }
+
+require 'dockage'
+require 'dockage/cli'
+
+Dockage::CLI.start(ARGV)

data/dockage.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dockage/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dockage'
+  spec.version       = Dockage::VERSION
+  spec.authors       = ['Sergey Besedin']
+  spec.email         = ['kr3ssh@gmail.com']
+  spec.summary       = 'Control multiple docker containers with ease'
+  spec.description   = 'Gem to manage multiple docker containers at once'
+  spec.homepage      = 'http://github.com/kr3ssh/dockage'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version     = '>= 1.9'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = %w( dockage )
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'thor'
+  spec.add_dependency 'colorize'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/dockage/cli.rb

@@ -0,0 +1,100 @@
+require 'dockage'
+require 'thor'
+require 'colorize'
+
+module Dockage
+  class CLI < Thor
+    def initialize(*)
+      super
+      Dockage.verbose_mode = options[:debug] || !!options[:verbose]
+      Dockage.debug_mode   = !!options[:debug]
+      Dockage.force_mode   = !!options[:force]
+    end
+
+    default_task :help
+    class_option 'verbose',  type: :boolean, banner: 'Enable verbose output mode', aliases: '-v'
+    class_option 'debug',  type: :boolean, banner: 'Enable debug output mode'
+    class_option 'quiet',  type: :boolean, banner: 'Suppress all output', aliases: '-q'
+    class_option 'force',  type: :boolean, banner: 'Run actions with force', aliases: '-f'
+
+    desc 'status [CONTAINER]', 'Show status overall or specified container'
+    def status(name = nil)
+      find_container(name) if name
+      puts Dockage::Docker.shell.status(name)
+    end
+
+    desc 'init', 'Create example config file'
+    def init
+      Dockage.create_example_config
+    end
+
+    desc 'up [CONTAINER]', 'Create and run specified [CONTAINER] or all configured containers'
+    def up(name = nil)
+      find_containers(name).each do |container|
+        Dockage.logger("Bringing up #{container[:name].yellow.bold}")
+        Dockage::Docker.shell.up(container)
+      end
+    end
+
+    desc 'reload [CONTAINER]', 'Reload specified [CONTAINER] or all configured containers'
+    def reload(name = nil)
+      find_containers(name).each do |container|
+        puts "Reloading #{container[:name].yellow.bold}"
+        Dockage::Docker.shell.reload(container)
+      end
+    end
+
+    desc 'provide CONTAINER', 'Run provision scripts on specified CONTAINER'
+    def provide(name)
+      container = find_container(name)
+      Dockage.error("SSH is not configured for #{container[:name].bold}") unless container[:ssh]
+      Dockage::Docker.shell.provide(container)
+    end
+
+    desc 'destroy [CONTAINER]', 'Destroy specified [CONTAINER] or all configured containers'
+    def destroy(name = nil)
+      find_containers(name).each do |container|
+        Dockage::Docker.shell.stop(container[:name])
+        Dockage::Docker.shell.destroy(container[:name])
+      end
+    end
+
+    desc 'ssh CONTAINER', 'SSH login to CONTAINER'
+    def ssh(name)
+      container = find_container(name)
+      Dockage.error("SSH is not configured for #{container[:name].bold}") unless container[:ssh]
+      Dockage::SSH.connect(container[:ssh])
+    end
+
+    desc 'shellinit', 'export DOCKER_HOST variable to current shell'
+    def shellinit
+      puts Dockage::Docker.shell.shellinit
+    end
+
+    desc 'version', 'dockage and docker versions'
+    def version
+      puts <<CMD
+#{'Dockage'.bold}:
+\tGem version #{Dockage::VERSION}
+#{'Docker'.bold}:
+\t#{Dockage::Docker.shell.version.gsub(/\n/, "\n\t")}
+CMD
+    end
+
+    protected
+
+    def find_containers(name = nil)
+      if name
+        Dockage.settings[:containers].select { |x| x[:name].to_s == name.to_s }
+      else
+        Dockage.settings[:containers]
+      end
+    end
+
+    def find_container(name = nil)
+      container = find_containers(name).first
+      Dockage.error("There is no settings for container #{name.bold}") unless container
+      container
+    end
+  end
+end

data/lib/dockage/docker/parse.rb

@@ -0,0 +1,44 @@
+module Dockage
+  module Docker
+    module Parse
+      class << self
+        def parse_docker_ps(string)
+          header = string.shift
+
+          spaces = column_width = 0
+          keys = {}
+          header.chars.each_with_index do |char, i|
+            if i == (header.size - 1) || (char !~ /\s/ && spaces > 1)
+              keys.merge!(slice_column_from_string(header, i, column_width))
+              column_width = 0
+            end
+            spaces = char =~ /\s/ ? spaces + 1 : 0
+            column_width += 1
+          end
+
+          string.map do |container_string|
+            container           = Hash[keys.map { |k, v| [k, container_string[v[:start]..v[:stop]].strip] }]
+            container[:name]    = container[:names].to_s
+                                                   .split(',')
+                                                   .reject{ |v| v.include?('/') }
+                                                   .first
+            container[:running] = container[:status].downcase
+                                                    .include?('up') ? true : false
+            container
+          end
+        end
+
+        def slice_column_from_string(string, index, column_width)
+          start = index - column_width
+          stop = index < string.length - 1 ? (index - 1) : -1
+          header_key = string[start..stop].strip
+                                          .downcase
+                                          .gsub(/\s/, '_')
+                                          .to_sym
+
+          { header_key => { start: start, stop: stop } }
+        end
+      end
+    end
+  end
+end

data/lib/dockage/docker/shell.rb

@@ -0,0 +1,154 @@
+module Dockage
+  module Docker
+    class Shell
+
+      DOCKER_DEFAULT_HOST = 'unix:///var/run/docker.sock'
+
+      def initialize
+        @env = "DOCKER_HOST=#{Dockage.settings[:docker_host] || DOCKER_DEFAULT_HOST}"
+      end
+
+      def pull(image)
+        invoke("pull #{image}", attach_std: true)
+      end
+
+      def start(name)
+        if container_running?(name)
+          Dockage.logger("Container #{name.bold.yellow} is already running")
+          return
+        end
+        invoke("start #{name}", catch_errors: true)
+      end
+
+      def stop(name)
+        unless container_running?(name)
+          Dockage.logger("Container #{name.bold.yellow} is not running")
+          return
+        end
+        invoke("stop #{name}", catch_errors: true)
+      end
+
+      def destroy(name)
+        unless container_exists?(name)
+          Dockage.logger("Container #{name.bold.yellow} not found")
+          return
+        end
+        Dockage.logger("Destroying container #{name.bold.yellow}")
+        invoke("rm #{name}", catch_errors: false)
+      end
+
+      def provide(container)
+        raise SSHOptionsError unless container[:ssh]
+        unless container_running?(container[:name])
+          Dockage.error("Container #{container[:name].bold.yellow} is not running")
+        end
+        container[:provision].each do |provision|
+          SSH.execute(provision, container[:ssh])
+        end
+      end
+
+      def build
+        invoke('build', attach_std: true)
+      end
+
+      def ps(name = nil, all = false)
+        ps_output = invoke("ps --no-trunc #{all && '-a '}", attach_std: false).split(/\n/)
+        containers = Parse.parse_docker_ps(ps_output)
+        containers.reject! { |con| con[:name] != name } if name
+        containers
+      end
+
+      def up(container)
+        if container_running?(container[:name])
+          Dockage.logger("Container #{container[:name].bold} is already up. Nothing to do")
+          return
+        end
+        return start(container[:name]) if container_exists?(container[:name])
+        pull(container[:image]) if container[:keep_fresh]
+        run(container[:image], container)
+      end
+
+      def reload(container)
+        stop(container[:name]) if container_running?(container[:name])
+        destroy(container[:name]) if container_exists?(container[:name])
+        up(container)
+      end
+
+      def status(name = nil)
+        output = ''
+
+        containers = Dockage.settings[:containers]
+        containers = containers.select { |con| con[:name] == name } if name
+
+        active_containers = ps(name, true)
+        containers.each do |container|
+          output += "#{container[:name].to_s.bold.yellow} is "
+          docker_container = active_containers.select { |con| con[:name] == container[:name] }.first
+          if docker_container
+            output += docker_container[:running] ? 'running'.green : 'not running'.red
+          else
+            output += 'not exists'.red
+          end
+          output += "\n"
+        end
+
+        output
+      end
+
+      def version
+        invoke('version')
+      end
+
+      def shellinit
+        "export #{env}"
+      end
+
+      def container_running?(name)
+        ps(name).any?
+      end
+
+      def container_exists?(name)
+        ps(name, true).any?
+      end
+
+      def run(image, opts = {})
+        command = "run" \
+          "#{opts[:detach] == false || ' -d'}" \
+          "#{opts[:links]   && opts[:links].map { |link| " --link #{link}" }.join}" \
+          "#{opts[:volumes] && opts[:volumes].map { |volume| " -v #{volume}" }.join}" \
+          "#{opts[:ports]   && opts[:ports].map { |port| " -p #{port}" }.join}" \
+          "#{opts[:name]    && " --name #{opts[:name]}"}" \
+          " #{image}" \
+          "#{opts[:cmd] && " /bin/sh -c '#{opts[:cmd]}'"}"
+        invoke(command)
+      end
+
+      private
+
+      def invoke(cmd, opts = {})
+        command = "#{@env} docker #{cmd}"
+        Dockage.verbose(command)
+        if opts[:attach_std]
+          output = sys_exec(command, opts[:catch_errors])
+        else
+          output = `#{command}`
+        end
+        Dockage.debug(output)
+        output
+      end
+
+      def sys_exec(cmd, catch_errors = true)
+        Open3.popen3(cmd.to_s) do |stdin, stdout, stderr|
+          @in, @out, @err = stdin, stdout.gets, stderr.gets
+          @in.close
+          Dockage.verbose(@out.strip) if @out && !@out.empty?
+          if @err && !@err.strip.empty?
+            puts @err.strip.red
+            @ruined = true
+          end
+        end
+        exit 1 if catch_errors && @ruined
+      end
+    end
+  end
+end

data/lib/dockage/docker.rb

@@ -0,0 +1,15 @@
+require 'open3'
+require 'dockage'
+
+module Dockage
+  module Docker
+    autoload :Parse,  'dockage/docker/parse'
+    autoload :Shell,  'dockage/docker/shell'
+
+    class << self
+      def shell
+        @shell ||= Shell.new
+      end
+    end
+  end
+end

data/lib/dockage/settings.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+
+module Dockage
+  class Settings
+    class << self
+      def load(config_path = 'dockage.yml')
+        raise DockageConfigNotFound unless File.exist? config_path
+        deep_symbolize_keys(YAML.load_file(config_path))
+      end
+
+      private
+
+      def deep_symbolize_keys(object)
+        case object
+        when Array
+          object.map{ |v| deep_symbolize_keys(v) }
+        when Hash
+          result = {}
+          object.each { |k,v| result[k.to_sym] = deep_symbolize_keys(v) }
+          result
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/dockage/ssh.rb

@@ -0,0 +1,48 @@
+module Dockage
+  class SSH
+    class << self
+      SSH_OPTS = %w( StrictHostKeyChecking=no UserKnownHostsFile=/dev/null )
+
+      def execute(provision, opts)
+        return Dockage.logger('Nothing to provide') unless provision
+        set_ssh_command(opts)
+        Dockage.logger("Provisioning #{ provision.map{ |k,v| "#{k.to_s.yellow}: #{v}" }.join }")
+        execute = "#{@command} #{provision[:inline]}" if provision[:inline]
+        if provision[:script]
+          Dockage.error("File #{provision[:script].bold} is not exist") unless File.exist?(provision[:script])
+          execute = "cat #{provision[:script]} | #{@command}"
+        end
+        Dockage.verbose(execute)
+        system(execute)
+      end
+
+      def connect(opts)
+        set_ssh_command(opts)
+        Dockage.debug(@command)
+        system(@command)
+        exit 0
+      end
+
+      def set_ssh_command(opts)
+        raise SSHOptionsError if !opts[:login] || !opts[:host]
+        return if @command
+        @command = which_ssh
+        @command += SSH_OPTS.map { |opt| " -o #{opt}" }.join if SSH_OPTS.any?
+        @command += " -i #{opts[:identity_file]}" if opts[:identity_file]
+        @command += " #{opts[:login]}@#{opts[:host]}"
+        @command += " -p #{opts[:port]}" if opts[:port]
+        @command += " -q" unless Dockage.verbose_mode
+      end
+
+      private
+
+      def which_ssh
+        Dockage.which('ssh')
+      end
+
+      def which_ssh_add
+        Dockage.which('ssh-add')
+      end
+    end
+  end
+end

data/lib/dockage/templates/dockage.yml

@@ -0,0 +1,21 @@
+docker_host: unix:///var/run/docker.sock
+containers:
+  - name: postgres
+    image: postgres:latest
+    keep_fresh: false
+    ports:
+      - '2220:22'
+    volumes:
+      - /tmp/data/pg:/var/lib/postgres/data
+    ssh:
+      enabled: true
+      login: root
+      host: 127.0.0.1
+      port: 2220
+    provision:
+      - inline: 'whoami'
+
+  - name: hello
+    keep_fresh: true
+    image: debian:jessie
+    cmd: 'while true; do echo hello world; sleep 1; done'

data/lib/dockage/version.rb

@@ -0,0 +1,3 @@
+module Dockage
+  VERSION = '0.1.0'
+end

data/lib/dockage.rb

@@ -0,0 +1,73 @@
+require 'fileutils'
+require 'dockage/version'
+require 'colorize'
+
+module Dockage
+  autoload :Settings, 'dockage/settings'
+  autoload :Docker, 'dockage/docker'
+  autoload :SSH, 'dockage/ssh'
+
+  class DockageError          < StandardError; end
+  class DockageConfigNotFound < DockageError; end
+  class DockageConfigExists   < DockageError; end
+  class ProvideError          < DockageError; end
+  class InstallError          < DockageError; end
+  class InvalidOptionError    < DockageError; end
+  class SSHOptionsError       < DockageError; end
+
+  class << self
+    attr_accessor :debug_mode
+    attr_accessor :verbose_mode
+    attr_accessor :quiet_mode
+    attr_accessor :force_mode
+
+    def root
+      @root ||= Dir.pwd
+    end
+
+    def config_path
+      File.join(root, 'dockage.yml')
+    end
+
+    def settings
+      @settings ||= Settings.load(config_path)
+    end
+
+    def create_example_config
+      raise DockageConfigExists if File.exist? config_path
+      FileUtils.cp(File.expand_path('../dockage/templates/dockage.yml', __FILE__), config_path)
+      puts 'Created example config dockage.yml'
+    end
+
+    def which(executable)
+      if File.file?(executable) && File.executable?(executable)
+        executable
+      elsif ENV['PATH']
+        path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
+          File.executable?(File.join(p, executable))
+        end
+        path && File.expand_path(executable, path)
+      end
+    end
+
+    def debug(string)
+      return unless string
+      puts string.magenta if Dockage.debug_mode
+    end
+
+    def verbose(string)
+      return unless string
+      puts string.blue if Dockage.verbose_mode
+    end
+
+    def logger(string)
+      return unless string
+      puts "> #{string}" unless Dockage.quiet_mode
+    end
+
+    def error(string = 'unknown error')
+      puts string.red unless Dockage.quiet_mode
+      exit 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,87 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # These two settings work together to allow you to limit a spec run
+  #   # to individual examples or groups you care about by tagging them with
+  #   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  #   # get run.
+  #   config.filter_run :focus
+  #   config.run_all_when_everything_filtered = true
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  #   # For more details, see:
+  #   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = 'doc'
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: dockage
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sergey Besedin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  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: colorize
+  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.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+description: Gem to manage multiple docker containers at once
+email:
+- kr3ssh@gmail.com
+executables:
+- dockage
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/dockage
+- dockage.gemspec
+- lib/dockage.rb
+- lib/dockage/cli.rb
+- lib/dockage/docker.rb
+- lib/dockage/docker/parse.rb
+- lib/dockage/docker/shell.rb
+- lib/dockage/settings.rb
+- lib/dockage/ssh.rb
+- lib/dockage/templates/dockage.yml
+- lib/dockage/version.rb
+- spec/spec_helper.rb
+homepage: http://github.com/kr3ssh/dockage
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Control multiple docker containers with ease
+test_files:
+- spec/spec_helper.rb