jarl 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5f658f6a2817ddf675c13d89d831c744dd27fcf
+  data.tar.gz: 087abc1978c7461efc0e2b2154b321ad4c0c1285
+SHA512:
+  metadata.gz: abfa4bd3f766e2d50352076b32ab0d1e56151fddd19ea8c3c769e44d971e11eecc0148c6187c6077a0fff02b77befaa1e7567507467a1f40cf1a2ed2e2513735
+  data.tar.gz: 1f397a352b7a36204e4ad6888235b7bf0b34d0d267b1084fbbd0d4bb6fc562bc22dd0078e92365d6308f9c2832216c655bd9431317694315317b06be772d5256

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alex Kukushkin
+
+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 @@
+# Jarl
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jarl'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jarl
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/jarl/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,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Run specs'
+task default: :spec

data/bin/jarl

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/jarl'
+
+Jarl::CLI.start

data/jarl.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jarl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jarl'
+  spec.version       = Jarl::VERSION
+  spec.authors       = ['Alex Kukushkin']
+  spec.email         = ['alex.kukushkin@cubits.com']
+  spec.summary       = %q{Jarl, docker container management tool}
+  spec.description   = %q{Jarl, docker container management tool}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor', '~> 0.19'
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/jarl/application.rb

@@ -0,0 +1,101 @@
+module Jarl
+  class Application
+    attr_reader :group, :name, :image, :volumes, :ports, :environment, :entrypoint, :command
+
+    # Create Application object from application definition:
+    #
+    # app_name:
+    #   image: blabla
+    #   volumes:
+    #     - /host/path:/container/path
+    #   ports:
+    #     - 1234:5678
+    #   command: blabla
+    #
+    def initialize(group, name, params)
+      @group = group
+      @name = name
+      @image = params['image'] || fail("Application '#{self}' has no 'image' defined")
+      unless @image.is_a?(String)
+        fail "Application '#{self}' has invalid 'image' definition, String is expected"
+      end
+      @volumes = params['volumes'] || []
+      unless @volumes.is_a?(Array)
+        fail "Application '#{self}' has invalid 'volumes' definition, Array is expected"
+      end
+      @ports = params['ports'] || []
+      unless @ports.is_a?(Array)
+        fail "Application '#{self}' has invalid 'ports' definition, Array is expected"
+      end
+      @environment = params['environment'] || {}
+      unless @environment.is_a?(Hash)
+        fail "Application '#{self}' has invalid 'environment' definition, Hash is expected"
+      end
+      @entrypoint = params['entrypoint']
+      if @entrypoint && !@entrypoint.is_a?(String)
+        fail "Application '#{self}' has invalid 'entrypoint' definition, String is expected"
+      end
+      @command = params['command']
+      if @command && !@command.is_a?(String)
+        fail "Application '#{self}' has invalid 'command' definition, String is expected"
+      end
+    end
+
+    def full_name
+      "#{group}.#{name}"
+    end
+
+    def image_is_a_path?
+      image =~ /^[~\.\/]/
+    end
+
+    def running?
+      running_container
+    end
+
+    def running_container
+      Docker.containers_running.find { |c| c.name == full_name }
+    end
+
+    def start
+      running_container.stop! if running?
+      Docker.start(
+        name: full_name,
+        image: image_name,
+        volumes: volumes,
+        ports: ports,
+        environment: environment,
+        command: command
+      )
+    end
+
+    def build
+      fail 'Not a file based image' unless image_is_a_path?
+      Docker::Image.new(image_name, image_path).build!
+    end
+
+    def image_name
+      image_is_a_path? ? name : image
+    end
+
+    def image_path
+      image_is_a_path? ? image : nil
+    end
+
+    def show_log(*_args)
+      return unless running?
+      begin
+        IO.popen "docker logs -f #{running_container.id}", 'r' do |p|
+          str = '<<< STARTED >>>'
+          puts "#{esc_yellow full_name}: #{str}" while str = p.gets
+        end
+      rescue Interrupt
+        #
+      end
+    end
+
+    def to_s
+      full_name
+    end
+  end # class Application
+end # module Jarl

data/lib/jarl/base.rb

@@ -0,0 +1,48 @@
+module Jarl
+  #
+  # Load config and application definitions
+  #
+  def self.load
+    abort 'Docker is not installed' unless Docker.installed?
+    if Jarl.jarl_files.empty?
+      abort 'No *.jarl files found'
+    elsif Jarl.applications.empty?
+      abort 'No application definitions found'
+    end
+    true
+  end
+
+  #
+  # Returns list of found *.jarl files
+  #
+  def self.jarl_files
+    @jarl_files ||= load_jarl_files
+  end
+
+  # Returns list of registered applications
+  #
+  def self.applications
+    @applications ||= jarl_files.map do |jf|
+      begin
+        jf.applications.map { |app_name, params| Application.new(jf.name, app_name, params) }
+      rescue StandardError => e
+        abort "Failed to parse application definition in file '#{jf.path}': #{e}"
+      end
+    end.flatten
+  end
+
+  # Returns list of applications matching the pattern
+  #
+  def self.find_applications_by(pattern)
+    applications.select { |a| a.full_name.index(pattern) }
+  end
+
+  private
+
+  def self.load_jarl_files
+    Pathname.glob(Pathname.pwd + '**' + '*.jarl').map do |p|
+      JarlFile.new(p)
+    end
+  end
+
+end # module Jarl

data/lib/jarl/cli.rb

@@ -0,0 +1,150 @@
+require 'thor'
+
+module Jarl
+  class CLI < Thor
+    # global options
+    #
+    class_option :config,
+      aliases: '-c',
+      type: :string,
+      desc: 'Use specified config file (defaul: ~/.jarl)'
+
+    #
+    desc 'status [NAME]', 'Show applications statuses'
+    def status(name = nil)
+      Jarl.load
+      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      show_jarl_applications_status(apps)
+    end
+    default_task :status
+
+    #
+    desc 'up [NAME]', '(Re)start applications'
+    def up(name = nil)
+      Jarl.load
+      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      apps.each do |app|
+        puts esc_green(app.running? ? "Restarting '#{app}'..." : "Starting '#{app}'...")
+        app.start
+      end
+      # show_jarl_applications_status(apps)
+    end
+
+    #
+    desc 'down [NAME]', 'Stop applications'
+    def down(name = nil)
+      Jarl.load
+      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      apps.each do |app|
+        next unless app.running?
+        puts esc_yellow "Stopping '#{app}'..."
+        app.running_container.stop!
+      end
+    end
+
+    #
+    option :ip, type: :boolean, desc: 'Show only IPs'
+    desc 'inspect [NAME]', 'Inspect applications'
+    def inspect(name = nil)
+      Jarl.load
+      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      apps.each do |app|
+        if options[:ip]
+          puts app.running_container.ip if app.running?
+        else
+          show_jarl_application_inspect(app)
+        end
+      end
+    end
+
+    desc 'build [NAME]', '(Re)build docker images'
+    def build(name = nil)
+      Jarl.load
+      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      apps.select(&:image_is_a_path?).each do |app|
+        puts esc_yellow "Building image for '#{app}'..."
+        app.build
+      end
+    end
+
+    desc 'logs [NAME]', 'Show log output for applications'
+    def logs(name = nil)
+      Jarl.load
+      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      threads = []
+      apps.select(&:running?).each do |app|
+        threads << Thread.new { app.show_log }
+      end
+      begin
+        threads.each(&:join)
+      rescue Interrupt
+        #
+      end
+      puts
+    end
+
+    desc 'version', 'Show Jarl version'
+    def version
+      puts app_name_version
+    end
+
+    private
+
+    def app_name_version
+      "Jarl v#{Jarl::VERSION}"
+    end
+
+    def show_jarl_applications_status(apps)
+      if apps.size == 0
+        puts esc_yellow 'No applications found'
+        return
+      end
+      max_full_name_len = [apps.map(&:full_name).map(&:size).max, 12].max
+      puts esc_format(
+        ['APPLICATION', max_full_name_len],
+        ['RUNNING', 12],
+        ['UPTIME', 12],
+        ['IP', 12],
+        ['PORTS']
+        # ['IMAGE']
+      )
+      apps.each do |app|
+        container = app.running_container
+        puts esc_format(
+          [app.full_name, max_full_name_len, :yellow],
+          (app.running? ? [container.id, 12, :green] : ['no', 12]),
+          (app.running? ? [seconds_to_human(container.uptime), 12, :yellow] : ['', 12]),
+          (app.running? ? [container.ip, 12, :yellow] : ['', 12]),
+          (app.running? ? [container.ports.map { |p| "#{p[:from]}"}.join(', ')] : [''])
+
+          # (app.image_is_a_path? ? ["path: #{app.image}"] : [app.image])
+        )
+      end
+      # puts "#{app.full_name} (#{app.image})"
+      # puts "  image: #{app.image}"
+      # puts "  volumes: #{app.volumes}"
+      # puts "  ports: #{app.ports}"
+      # puts "  environment: #{app.environment}"
+      # puts "  entrypoint: #{app.entrypoint}"
+      # puts "  command: #{app.command}"
+    end
+
+    def show_jarl_application_inspect(app)
+      unless app.running?
+        puts esc_yellow("#{app.full_name}: ") + 'down'
+        return
+      end
+      container = app.running_container
+      puts esc_yellow "#{app.full_name}: " + esc_green(container.id)
+      puts "     name: #{esc_yellow container.name}"
+      puts "    image: #{esc_yellow container.image}"
+      puts "  full ID: #{esc_yellow container.long_id}"
+      puts "   uptime: #{esc_yellow seconds_to_human container.uptime}"
+      puts "       IP: #{esc_yellow container.ip}"
+      puts "    ports: #{esc_yellow container.ports.map { |p| "#{p[:from]}->#{p[:to]}"}.join(', ')}"
+      puts "  volumes: #{esc_yellow container.params['Volumes']}"
+      # puts "       ps: #{esc_yellow container.ps}"
+      # puts "   params: #{esc_yellow container.params}"
+    end
+  end # class CLI
+end # module Jarl

data/lib/jarl/console.rb

@@ -0,0 +1,88 @@
+module Console
+  module Shell
+    def sh(*args)
+      puts "> #{args.join(' ')}"
+      system(*args)
+    end
+  end # module Shell
+
+  module Utils
+    def seconds_to_human(s)
+      s = s.round
+      m = (s / 60).floor
+      s = s % 60
+      h = (m / 60).floor
+      m = m % 60
+      d = (h / 24).floor
+      h = h % 24
+
+      output = "#{s}s"
+      output = "#{m}m " + output if m > 0 || h > 0 || d > 0
+      output = "#{h}h " + output if h > 0 || d > 0
+      output = "#{d}d " + output if d > 0
+      output
+    end
+  end # module Utils
+
+  module Colors
+    # Returns ANSI escaped string.
+    #
+    def esc_string(esc, text)
+      esc + text.to_s + "\e[0m"
+    end
+
+    # Returns ANSI escaped string for the red colored text.
+    #
+    def esc_red(text)
+      esc_string "\e[31m", text
+    end
+
+    # Returns ANSI escaped string for the green colored text.
+    #
+    def esc_green(text)
+      esc_string "\e[32m", text
+    end
+
+    # Returns ANSI escaped string for the yellow colored text.
+    #
+    def esc_yellow(text)
+      esc_string "\e[33m", text
+    end
+
+    # Returns ANSI escaped string for the blue colored text.
+    #
+    def esc_blue(text)
+      esc_string "\e[34m", text
+    end
+
+    # Returns ANSI escaped string for the bold text.
+    #
+    def esc_bold(text)
+      esc_string "\e[01;37m", text
+    end
+
+    # Returns string padded to given number of characters, text can be escaped.
+    #
+    def esc_pad(text, num, color = nil)
+      esc_text = text
+      case color
+      when :red, :yellow, :green
+        esc_text = send :"esc_#{color}", text
+      end
+      pad = esc_text.size - text.size
+      num > 0 ? ("%-#{num + pad}s" % esc_text) : esc_text
+    end
+
+    # Returns string with formatted and padded fields
+    # Each arg is an Array:
+    # [<text>, [padding_num], [color]]
+    #
+    def esc_format(*args)
+      out = []
+      args.each do |arg|
+        out << esc_pad(arg[0], arg[1] || 0, arg[2])
+      end
+      out.join(' ')
+    end
+  end # module Colors
+end # module Console

data/lib/jarl/docker.rb

@@ -0,0 +1,229 @@
+require 'json'
+
+module Jarl
+module Docker
+  INSECURE_KEY_PATH = '/home/vagrant/.ssh/insecure_key'
+
+  # Returns true if Docker is installed
+  #
+  def self.installed?
+    !`which docker`.empty?
+  end
+
+  # Returns available docker images
+  #
+  def self.images
+    @docker_images ||= Pathname.glob(Pathname.new(DOCKER_IMAGES_PATH).join('*/')).sort.map do |path|
+      Image.new(path.basename, path)
+    end
+  end
+
+  # Returns a list of used images
+  #
+  def self.images_used
+    used_images_list = File.readlines(USED_IMAGES_FILE) rescue ['']
+    used_images_list.map!(&:chomp)
+    @docker_images_used ||= images.select { |di| used_images_list.include?(di.name) }
+  end
+
+  # Returns a list of unused images
+  #
+  def self.images_unused
+    images - images_used
+  end
+
+  # Adds image to a list of used images
+  #
+  def self.images_used_add(name)
+    list = images_used.map(&:name)
+    list << name
+    File.open(USED_IMAGES_FILE, 'w') do |f|
+      f.puts list.join("\n")
+    end
+    reload!
+  end
+
+  # Removes image from a list of used images
+  #
+  def self.images_used_remove(name)
+    list = images_used.map(&:name).select { |n| n != name }
+    File.open(USED_IMAGES_FILE, 'w') do |f|
+      f.puts list.join("\n")
+    end
+    reload!
+  end
+
+  # Returns a list of running docker containers
+  #
+  def self.containers_running
+    return @docker_containers_running if @docker_containers_running
+    container_ids = `docker ps -q`.split("\n")
+    @docker_containers_running = container_ids.map do |id|
+      Container.new id
+    end
+    @docker_containers_running
+  end
+
+  # Reloads lists of images and containers
+  #
+  def self.reload!
+    @docker_images = nil
+    @docker_images_used = nil
+    @docker_containers_running = nil
+  end
+
+  # Cleans unused images
+  #
+  def self.clean_images
+    sh "docker rmi $(docker images -a | grep '^<none>' | awk '{print $3}') >/dev/null 2>&1"
+  rescue RuntimeError => e
+    # omit conflicting images error reports
+    raise unless e.to_s =~ /Command failed/
+  end
+
+  # Cleans stopped containers
+  #
+  def self.clean_containers
+    sh "docker rm $(docker ps -a | grep 'Exited' | awk '{print $1}')"
+  rescue RuntimeError => e
+    # omit conflicting images error reports
+    raise unless e.to_s =~ /Command failed/
+  end
+
+  # Start container defined by params
+  #
+  def self.start(params)
+    opts = []
+    opts << params[:volumes].map do |v|
+      "-v #{v}"
+    end.join(' ')
+    opts << params[:ports].map do |p|
+      "-p #{p}"
+    end.join(' ')
+    opts << params[:environment].map do |k, v|
+      "-e #{k}=#{v}"
+    end.join(' ')
+    docker_cmd = "docker run -d #{opts.join(' ')} " \
+      " --hostname #{params[:name]} " \
+      " --name #{params[:name]} #{params[:image]} #{params[:command]}"
+    # puts docker_cmd
+    sh docker_cmd
+  end
+
+  # Image
+  #
+  class Image
+    attr_accessor :name, :path
+
+    def initialize(name, path)
+      @name = name.to_s
+      @path = path
+    end
+
+    def prebuilt?
+      self.class.prebuilt_image_names.include?(name)
+    end
+
+    def running?
+      !!running_container
+    end
+
+    def running_container
+      Docker.containers_running.select { |c| c.name == name }.first
+    end
+
+    def build!
+      sh "docker build -t #{name} #{path}"
+    end
+
+    def start!
+      Container.clean_containers(name)
+      run_flags = "--name=#{name} --hostname=#{name} -d"
+      sh "docker run #{run_flags} #{name}"
+    end
+
+    def stop!
+      running_container.stop!
+    end
+
+    def open_ssh_session!
+      running_container.open_ssh_session!
+    end
+
+    def use!
+      build! unless prebuilt?
+      Docker.images_used_add(name)
+    end
+
+    def unuse!
+      Docker.images_used_remove(name)
+    end
+
+    def used?
+      Docker.images_used.map(&:name).include?(name)
+    end
+
+    def self.prebuilt_image_names
+      return @prebuilt_image_names if @prebuilt_image_names
+      di = `docker images`
+      @prebuilt_image_names = di.split("\n").map do |line|
+        m = line.match(/^(\S*)\s*/)
+        m[1]
+      end
+      @prebuilt_image_names
+    end
+  end # class Image
+
+  # Container
+  #
+  class Container
+    attr_accessor :id, :long_id, :name, :image, :image_id, :ip, :ps, :ports, :params
+
+    def initialize(id)
+      @id = id
+      @ps = `docker ps | grep #{id}`
+      container_inspect = `docker inspect #{id}`
+      @params = JSON.parse(container_inspect).first
+      @long_id = params['Id']
+      @name = params['Name'].gsub('/', '')
+      @image = params['Config']['Image']
+      @image_id = params['Image']
+      @ip = params['NetworkSettings']['IPAddress']
+      port_maps = params['NetworkSettings']['Ports']
+      @ports = port_maps.keys.map do |port|
+        { from: port, to: port_maps[port] }
+      end
+    end
+
+    def open_ssh_session!
+      ssh_flags = "-oStrictHostKeyChecking=no -i #{INSECURE_KEY_PATH}"
+      sh "ssh #{ssh_flags} root@#{ip}"
+    end
+
+    def stop!
+      sh "docker stop #{name}"
+      clean!
+    end
+
+    def clean!
+      self.class.clean_containers(name)
+    end
+
+    def uptime
+      params['State'] && params['State']['StartedAt'] &&
+      Time.now.utc - DateTime.parse(params['State']['StartedAt']).to_time.utc
+    end
+
+    def self.clean_containers(*names)
+      names.each do |name|
+        begin
+          sh "docker rm #{name} >/dev/null 2>&1"
+        rescue RuntimeError => e
+          # omit reports on missing container
+          raise unless e.to_s =~ /Command failed/
+        end
+      end
+    end
+  end # class ContainerInfo
+end # module Docker
+end # module Jarl

data/lib/jarl/jarl_file.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+require 'pathname'
+
+module Jarl
+  class JarlFile
+    attr_reader :path, :name, :applications
+
+    def initialize(path)
+      @path = Pathname.new(path)
+      @name = @path.basename('.jarl')
+      load
+    end
+
+    private
+
+    def load
+      @applications = YAML.load File.read(path)
+    end
+
+  end # class JarlFile
+end # module Jarl

data/lib/jarl/version.rb

@@ -0,0 +1,3 @@
+module Jarl
+  VERSION = '0.2.0'
+end

data/lib/jarl.rb

@@ -0,0 +1,15 @@
+# require 'rubygems'
+# require 'bundler/setup'
+# Bundler.setup
+
+require 'jarl/base'
+require 'jarl/version'
+require 'jarl/cli'
+require 'jarl/application'
+require 'jarl/jarl_file'
+require 'jarl/docker'
+require 'jarl/console'
+
+include Console::Colors
+include Console::Shell
+include Console::Utils

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+Bundler.setup
+
+require_relative '../lib/jarl'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: jarl
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Alex Kukushkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-03 00:00:00.000000000 Z
+dependencies:
+- !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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: Jarl, docker container management tool
+email:
+- alex.kukushkin@cubits.com
+executables:
+- jarl
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/jarl
+- jarl.gemspec
+- lib/jarl.rb
+- lib/jarl/application.rb
+- lib/jarl/base.rb
+- lib/jarl/cli.rb
+- lib/jarl/console.rb
+- lib/jarl/docker.rb
+- lib/jarl/jarl_file.rb
+- lib/jarl/version.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Jarl, docker container management tool
+test_files:
+- spec/spec_helper.rb