dockerkit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f938406c52b63b22d7dc3af287d33e5231c8256d
+  data.tar.gz: 97486a2baf49fc7d987a85b578625a493c7a42d8
+SHA512:
+  metadata.gz: 90f1caa5e4109ea580e17dade20a593abadd2abcb5abc6c016aaa506e74a812232dc7f43dd0c495fc8aa2a9feff44ccf83219511fa92bf7f1ff0a62a80b93d28
+  data.tar.gz: a56e4a9400a506c9b1fda282edb04ea9a974f9e7c3a976f3985c3712bd6a749b2308dcc7bcd020d5c6bc29be33f1e211c2f42568322c00c23964ec23a7cd75a6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 shaoyang
+
+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,39 @@
+# Dockerkit
+
+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/dockerkit`. 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 'dockerkit'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dockerkit
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/shao4phone@gmail.com/dockerkit.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/dk

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "dockerkit"
+Dockerkit::Base.start

data/lib/alias.yml

@@ -0,0 +1,9 @@
+mysql: docker run  -d --rm -p3306:3306 --name mysql -e MYSQL_ALLOW_EMPTY_PASSWORD=true mysql
+mongo: docker run  -d --rm -p27017:27017 --name mongo  mongo
+postgres: docker run -d --rm -p5432:5432 --name postgres  postgres
+bash: dk exec -o "'-it'" --cmd "/bin/bash"
+sh: dk exec -o "'-it'" --cmd "/bin/sh"
+lsv: docker volume ls
+v: docker volume
+lsn: docker network ls
+net: docker network

data/lib/concerns/constants.rb

@@ -0,0 +1,3 @@
+DOCKER_CONFIG_FILE = 'docker.rc.yml'.freeze
+DOCKER_FILE = 'Dockerfile'.freeze
+DOCKER_COMPOSE_FILE = 'docker-compose.yml'.freeze

data/lib/concerns/container_tasks.rb

@@ -0,0 +1,110 @@
+module ContainerTasks
+  extend ActiveSupport::Concern
+  module ClassMethods
+  end
+
+  included do
+    desc 'lsc [KEYWORD] [-n nk] [-i ik]', <<-LONG
+    'list all container which container name match the patten'
+    example:
+      dk lsc                    #list all containers
+      dk lsc test               #list all containers which include string test;
+      dk lsc test -n nk         #list all containers which include test and name include nk;
+      dk lsc test -i ik         #list all containers which include test and image include ik;
+      dk lsc -n nk -i tk        #list all containers which name include nk and image include ik
+    LONG
+    method_option :name, type: :string, aliases: 'n'
+    method_option :image, type: :string, aliases: 'i'
+    def lsc(keyword = nil)
+      ret = Container.find(keyword: keyword, name: options['name'], image: options['image'])
+      Container.print_table(ret)
+    end
+
+    desc 'del [KEYWORD] [-n nk] [-i ik]', <<-LONG
+    'delete all containers which container data match the patten'
+    example:
+      dk del                    #delete all containers
+      dk del test               #delete all containers which include string test;
+      dk del test -n nk         #delete all containers which include test and name include nk;
+      dk del test -i ik         #delete all containers which include test and image include ik;
+      dk del -n nk -i tk        #delete all containers which name include nk and image include ik
+    LONG
+    method_option :name, type: :string, aliases: 'n'
+    method_option :image, type: :string, aliases: 'i'
+    def del(keyword = nil)
+      ret = Container.find(keyword: keyword, name: options['name'], image: options['image'])
+      Container.print_table(ret)
+      say('The listed containers will be deleted, ARE YOU SURE.'.blue)
+      answer = ask('(y=YES;q=QUIT;i=ASK one by one)', limited_to: %w[y q i])
+      return if answer == 'q'
+      ret.each do |container|
+        if answer == 'i'
+          say(container.to_s)
+          each_answer = ask('going to delete? (y=YES,n=NO,q=QUIT):')
+          next if each_answer == 'n'
+          break if each_answer == 'q'
+        end
+        container.del
+      end
+    end
+    map rm: :del
+    map rmc: :del
+
+
+
+  desc 'exec [KEYWORD] [-n nk] [-i ik] [--opts] [--cmd] [-s]', <<-LONG
+    select container which container_name match the patten and select some to run
+    example:
+      dk exec\
+      #list all container and select some to exec
+
+      dk exec test\
+      #list all container which include string test and select one to exec;
+
+      dk exec test -n nk\
+      #list all container which include test and name include nk and select one to exec;
+
+      dk exec test -t tk\
+      #list all container which include test and tag include tk and select one to exec;
+
+      dk exec -n nk -t tk\
+      #list all container which repository include nk and tag include tk and select one to push;
+
+      dk exec --opts "'-i -t --name test'" --cmd '/bin/bash'\
+      #NOTE  opts and cmd option ,use "''" to quot as sample
+      #list all container and exec as opts -it --name test and command is /bin/bash
+
+      dk exec --opts "'-i -t'" --cmd '/bin/bash' -s test.bash\
+      #NOTE  opts and cmd option ,use "''" to quot as sample
+      #list all container and exec as opts -it --name test and command is /bin/bash
+      #and save the command as alias and alias name is test.bash
+    LONG
+    method_option :opts, type: :string, aliases: 'o'
+    method_option :cmd, type: :string, aliases: 'c'
+    method_option :name, type: :string, aliases: 'n'
+    method_option :image, type: :string, aliases: 'i'
+    method_option :alias, type: :string, aliases: 's'
+
+    def exec(keyword = nil)
+      ret = Container.find(keyword: keyword, name: options['name'], image: options['image'])
+
+      if ret.count > 1
+        Container.print_table(ret) { |item, index| "[#{index + 1}]#{item}" }
+        question = ['please select one container to run:'].unshift(' ').unshift(' ').join("\n")
+        say(question.blue)
+        answer = ask('(q=QUIT;n=)', limited_to: ['q', *('1'..ret.count.to_s).to_a])
+        return if answer == 'q'
+      end
+
+
+      command = options['cmd'] || ask_with_default('Any command you want to run?', 'echo hello')
+      opts = options['opts'] || ask_with_default('Any option you want to set?', '-it')
+      index=(answer&.to_i||1)-1
+      xcommand=ret[index].exec(opts, command)
+      run(["dk","alias",options['alias'],xcommand].join(" ")) if options['alias']
+      run(xcommand.join(" "))
+    end
+
+
+  end
+end

data/lib/concerns/image_tasks.rb

@@ -0,0 +1,206 @@
+module ImageTasks
+  extend ActiveSupport::Concern
+  module ClassMethods
+  end
+
+  included do
+    desc 'ls [KEYWORD]  [-n nk] [-t tk]', <<-LONG
+    'list all images which image_name match the patten'
+    example:
+      dk ls                    #list all images
+      dk ls test               #search all images which include string test;
+      dk ls test -n nk      #search all images which include test and name include nk;
+      dk ls test -t tk       #search all images include test and tag include tk;
+      dk ls -n nk -t tk   #search all images which repository include nk and tag include tk
+    LONG
+    method_option :name, type: :string, aliases: 'n'
+    method_option :tag, type: :string, aliases: 't'
+    def ls(keyword = nil)
+      ret = Image.find(keyword: keyword, name: options['name'], tag: options['tag'])
+      Image.print_table(ret)
+      #      print_table([ret.unshift(Image.headers)])
+    end
+
+    desc 'rmi [KEYWORD] [-n nk] [-t tk]', <<-LONG
+    'delete images which image_name match the patten'
+    example:
+      dk rmi                    #delete all images
+      dk rmi test               #delete all images which include string test;
+      dk rmi test -n nk         #delete all images which include test and name include nk;
+      dk rmi test -t tk         #delete all images which include test and tag include tk;
+      dk rmi -n nk -t tk        #delete all images which repository include nk and tag include tk
+    LONG
+    method_option :name, type: :string, aliases: 'n'
+    method_option :tag, type: :string, aliases: 't'
+    def rmi(keyword = nil)
+      ret = Image.find(keyword: keyword, name: options['name'], tag: options['tag'])
+      Image.print_table(ret)
+      say('The listed images will be deleted, ARE YOU SURE?'.blue)
+      answer = ask('(y=YES;q=QUIT;i=ASK one by one)', limited_to: %w[y q i])
+      return if answer == 'q'
+      ret.each do |image|
+        if answer == 'i'
+          say(image.to_s)
+          each_answer = ask('going to delete? (y=YES,n=NO,q=QUIT):')
+          next if each_answer == 'n'
+          break if each_answer == 'q'
+        end
+        image.del
+      end
+    end
+
+    desc 'pull [IMAGENAME] [-as one two three]', <<-LONG
+     'pull ruby:2.3.4 -l myruby ruby:2.3'
+    LONG
+    method_option :local, type: :array, aliases: 'l'
+    def pull(name)
+      Image.pull(name)
+      binding.pry
+      if options['local']
+        options['local'].each do |new_name|
+          Image.tag(name, new_name)
+        end
+      end
+    end
+
+    desc 'push [KEYWORD] [-n nk] [-t tk]', <<-LONG
+    'select images which image_name match the patten and select some to push'
+    example:
+      dk push                    #list all images and select some to push
+      dk push test               #list all images which include string test and select some to push;
+      dk push test -n nk         #list all images which include test and name include nk and select some to push;
+      dk push test -t tk         #list all images which include test and tag include tk and select some to push;
+      dk push -n nk -t tk        #list all images which repository include nk and tag include tk and select some to push;
+    LONG
+    method_option :name, type: :string, aliases: 'n'
+    method_option :tag, type: :string, aliases: 't'
+    def push(keyword = nil)
+      ret = Image.find(keyword: keyword, name: options['name'], tag: options['tag'])
+      Image.print_table(ret)
+      say('The listed images will be pushed, ARE YOU SURE?'.blue)
+      answer = ask('(y=YES;q=QUIT;i=ASK one by one)', limited_to: %w[y q i])
+      return if answer == 'q'
+      ret.each do |image|
+        if answer == 'i'
+          say(image.to_s)
+          each_answer = ask('going to push? (y=YES,n=NO,c=YES and change repository name,q=QUIT):')
+          next if each_answer == 'n'
+          break if each_answer == 'q'
+          if each_answer == 'c'
+            new_rep = ask_with_default('New repository?', image.image_name)
+            Image.tag(image.image_name, new_rep)
+            image.repository, image.tag = new_rep.split(':')
+          end
+        end
+        image.push
+      end
+    end
+
+    desc 'tag [IMAGENAME] [-t one two three]', <<-LONG
+     tag image as new images
+
+     samples:
+
+     tag ruby:2.3.4 -t a:2.3.4 haha:2.3.4
+    LONG
+    method_option :as, type: :array
+    def tag(name)
+      image = search_with_ask(name, Image, 'which image you want to tag?')
+      say(image.to_s)
+      option ||= {}
+      new_image_name = option['as'] || ask('new image name?')
+      Image.tag(image.image_name, new_image_name)
+    end
+
+    desc 'xrun [KEYWORD] [-n nk] [-t tk] [--opts] [--cmd] [-s]', <<-LONG
+    select images which image_name match the patten and select some to run
+    example:
+      dk xrun\
+      #list all images and select some to run
+
+      dk xrun test\
+      #list all images which include string test and select one to run;
+
+      dk xrun test -n nk\
+      #list all images which include test and name include nk and select one to run;
+
+      dk xrun test -t tk\
+      #list all images which include test and tag include tk and select one to xrun;
+
+      dk xrun -n nk -t tk\
+      #list all images which repository include nk and tag include tk and select one to push;
+
+      dk xrun --opts "'-i -t --name test'" --cmd '/bin/bash'\
+      #NOTE  opts and cmd option ,use "''" to quot as sample
+      #list all images and run as opts -it --name test and command is /bin/bash
+
+      dk xrun --opts "'-i -t --name test'" --cmd '/bin/bash' -s test.bash\
+      #NOTE  opts and cmd option ,use "''" to quot as sample
+      #list all images and run as opts -it --name test and command is /bin/bash
+      #and save the command as alias and alias name is test.bash
+    LONG
+    method_option :opts, type: :string, aliases: 'o'
+    method_option :cmd, type: :string, aliases: 'c'
+    method_option :name, type: :string, aliases: 'n'
+    method_option :tag, type: :string, aliases: 't'
+    method_option :alias, type: :string, aliases: 's'
+
+    def xrun(keyword = nil)
+      ret = Image.find(keyword: keyword, name: options['name'], tag: options['tag'])
+      if ret.count==0
+        repository,tag=keyword.split(":")
+        ret=[Image.new(repository:repository,tag:tag)]
+      end
+
+      if ret.count > 1
+        Image.print_table(ret) { |item, index| "[#{index + 1}]#{item}" }
+        question = ['please select one image to run:'].unshift(' ').unshift(' ').join("\n")
+        say(question.blue)
+        answer = ask('(q=QUIT;n=)', limited_to: ['q', *('1'..ret.count.to_s).to_a])
+        return if answer == 'q'
+      end
+
+
+      command = options['cmd'] || ask_with_default('Any command you want to run?', '')
+      opts = options['opts'] || ask_with_default('Any option you want to set?', '-d')
+      index=(answer&.to_i||1)-1
+      xcommand=ret[index].launch(opts, command)
+      run(["dk","alias",options['alias'],xcommand].join(" ")) if options['alias']
+      run(xcommand.join(" "))
+    end
+
+    desc 'build [-d ./docker]', <<-LONG
+    build docker file
+
+    sample:
+
+    dk build -d ./docker
+    LONG
+    method_option :dir, type: :string, aliases: 'd', default: '.'
+    def build
+      dir = options['dir']
+      invoke(:init) if file_not_exist?("#{dir}/#{DOCKER_CONFIG_FILE}")
+      load_config(dir) do |config|
+        Image.build(DOCKER_FILE, config[:repository_urls].map { |url| "#{url}/#{config[:image_name]}" })
+      end
+    end
+
+    desc 'release [-d ./docker]', <<-LONG
+    release docker file
+
+    sample:
+
+    dk release -d ./docker
+    LONG
+    method_option :dir, type: :string, aliases: 'd', default: '.'
+    def release
+      dir = options['dir']
+      invoke(:init) if file_not_exist?("#{dir}/#{DOCKER_CONFIG_FILE}")
+      load_config(dir) do |config|
+        config[:repository_urls].map { |url| "#{url}/#{config[:image_name]}" }.each do |image_name|
+          Image.push(image_name)
+        end
+      end
+    end
+  end
+end

data/lib/dockerkit/version.rb

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

data/lib/dockerkit.rb

@@ -0,0 +1,147 @@
+require 'dockerkit/version'
+require 'thor'
+require 'colorize'
+require 'pry-byebug'
+require 'active_support'
+require 'active_support/core_ext'
+require 'yaml'
+require 'erubis'
+Dir[File.dirname(__FILE__) + '/models/*.rb'].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/concerns/*.rb'].each { |file| require file }
+
+class Hammer < Thor
+  include Thor::Actions
+end
+
+def hammer
+  Hammer.new
+end
+
+module Dockerkit
+  class Base < Thor
+    include Thor::Actions
+    include ContainerTasks
+    include ImageTasks
+
+    source_root File.dirname(__FILE__)
+
+    desc 'alias [NAME] [CMD]', <<-LONG
+     alias name with a cmd
+
+     Sample:
+         dk alias                            #list all alias
+         dk alias ls.mongo  dk ls mongo      #aliase ls.mongo as  command 'dk ls mongo'
+         dk alias ls.mongo -d                #delete alias ls.mongo
+    LONG
+    method_option :delete, type: :boolean, aliases: 'd'
+    method_option :help, type: :boolean, aliases: 'h'
+
+    def alias(name = nil, *cmds)
+      return say((Alias.all[name] || "No such Alias:#{name}").red) if options['help']
+      return Alias.list_alias unless name
+      return Alias.delete_alias(name) if name && options['delete']
+      return Alias.create_alias(name, cmds) if cmds
+    end
+
+    desc 'init [-d ./docker]', <<-LONG
+    init current folder for a docker related project
+
+
+    SAMPLE:
+      init -d ./docker     #init docker-compose , dockerfile, and dockerconfig in ./docker path
+    LONG
+
+    method_option :dir, type: :string, aliases: 'd', default: '.'
+    def init
+      dir = options['dir']
+      load_config(dir) do |config|
+        config[:image_name] = ask_with_default('Image name?', "#{File.basename(Dir.getwd)}:latest")
+        config[:repository_urls] = multi_ask('Add new repository_url?')
+      end
+      inside(dir) do
+        init_dockerfile if file_not_exist?(DOCKER_FILE.to_s) && ask('Need Create Dockerfile?'.red, limited_to: %w[y n]) == 'y'
+        init_docker_compose_file if file_not_exist?(DOCKER_COMPOSE_FILE.to_s) && ask('Need Create docker-compose file?'.red, limited_to: %w[y n]) == 'y'
+      end
+    end
+
+    desc '_[DOCKERCOMMAND]', 'invoke docker command directly'
+
+    desc '[ALIAS_NAME]', 'invoke alias'
+    def method_missing(method, *args)
+      return Alias.run(method.to_s, args) if Alias.all.key?(method.to_s)
+      return send(:docker, *args.unshift(method.to_s.gsub(/^_/, ''))) if method.to_s.start_with?('_')
+    end
+
+    private
+
+    def init_dockerfile(dir = '.')
+      load_config(dir) do |config|
+        config[:author] = ask_with_default('Author is ?', ENV['USER'].camelize)
+        config[:base_image] = ask_with_default('Base Image?', 'alpine')
+        config[:deamon_cmd] = ask_with_default('Deamon CMD?', 'tail -f /dev/null')
+        @config = config
+        template("#{self.class.source_root}/templates/Dockerfile", DOCKER_FILE)
+      end
+    end
+
+    def init_docker_compose_file(dir = '.')
+      load_config(dir) do |config|
+        config[:service_name] = ask_with_default('Service Name is ?', 'app')
+        @config = config
+        template("#{self.class.source_root}/templates/docker-compose.yml", DOCKER_COMPOSE_FILE)
+      end
+    end
+
+    def search_with_ask(name, klass, question)
+      ret = klass.search(name)
+      return ret.first if ret.size == 1
+      unless ret.empty?
+        q = ret.each_with_index.map { |image, i| "[#{i + 1}] #{image}" }
+        q.unshift(klass.headers)
+        # print_table(q)
+        say(q.join(''))
+        answer = ask(question, limited_to: ('1'..ret.size.to_s).to_a.unshift('q'))
+        return if answer == 'q'
+        ret[answer.to_i - 1]
+      end
+    end
+
+    def ask_with_default(question, default)
+      answer = ask("#{question.red} [default:#{default.blue}]:").chomp
+      answer.empty? ? default : answer
+    end
+
+    def load_config(dir)
+      inside dir do
+        create_file(DOCKER_CONFIG_FILE) unless File.exist?(DOCKER_CONFIG_FILE)
+        config = YAML.load_file(DOCKER_CONFIG_FILE) || {}
+        if block_given?
+          yield config
+          create_file(DOCKER_CONFIG_FILE, config.to_yaml)
+        end
+      end
+    end
+
+    def file_not_exist?(file)
+      !File.exist?(file)
+    end
+
+    def multi_ask(question)
+      ret = []
+      answer = 'start'
+      until answer.empty?
+        answer = ask("#{question.red},(ENTER directly will end the question)").chomp
+        ret.push answer unless answer.empty?
+      end
+      ret
+    end
+
+    def docker(*args)
+      hammer.run("docker #{args.join(' ')}")
+    end
+
+    def precheck
+      true
+    end
+  end
+end

data/lib/models/alias.rb

@@ -0,0 +1,52 @@
+class Alias
+  def self.all
+    default_yml = "#{__dir__}/../alias.yml"
+    extend_yml = "#{ENV['HOME']}/.dk/alias.yml"
+    default_alias = YAML.load_file(default_yml) || {}
+
+    extend_alias = File.exist?(extend_yml) ? YAML.load_file(extend_yml) : {}
+    ret = {}.merge(default_alias).merge(extend_alias)
+  end
+
+  def self.list_alias
+    hammer.say 'Aliases:'
+    all.each do |name, cmd|
+      hammer.say("   #{name}  ##{cmd}")
+    end
+  end
+
+  def self.create_alias(name, cmds)
+    extend_yml = "#{ENV['HOME']}/.dk/alias.yml"
+    extend_alias = File.exist?(extend_yml) ? YAML.load_file(extend_yml) : {}
+    extend_alias[name] = cmds.join(' ')
+    File.open(extend_yml, 'w') { |f| f.write extend_alias.to_yaml }
+  end
+
+  def self.delete_alias(name)
+    extend_yml = "#{ENV['HOME']}/.dk/alias.yml"
+    extend_alias = File.exist?(extend_yml) ? YAML.load_file(extend_yml) : {}
+    extend_alias.delete(name)
+    File.open(extend_yml, 'w') { |f| f.write extend_alias.to_yaml }
+  end
+
+  def self.run(name, args)
+    hash_opts, options = parse(args)
+    begin
+      command = Erubis::Eruby.new(options.unshift(all[name]).join(' ')).result(hash_opts)
+      hammer.run(command)
+    rescue => e
+      missed_opts = /`(.*)'/.match(e.message).captures.map { |i| "#{i}:<#{i}>" }.join(',')
+      hammer.say("pls provide opts #{missed_opts}")
+    end
+  end
+
+  def self.parse(args)
+    regexp = /:/
+    hash_opts = args.select { |item| regexp.match(item) }
+    options = args - hash_opts
+    split_options = Thor::Options.split(options)
+    hash_opts_obj = hash_opts.map { |item| item.split(':') }.to_h
+    hash_opts_obj['args'] = options.unshift('')
+    ret = [hash_opts_obj, split_options]
+  end
+end

data/lib/models/base.rb

@@ -0,0 +1,58 @@
+module Base
+  extend ActiveSupport::Concern
+  module ClassMethods
+    def raw_lines
+      hammer.run(command, capture: true).lines
+    end
+
+    def load(lines = raw_lines)
+      @headers = lines.first
+      @items = lines[1..-1].map do |line|
+        create(line)
+      end
+    end
+
+    def all
+      load
+    end
+
+    def headers_raw
+      @headers
+    end
+
+    def search(*keywords)
+      keyword, = keywords
+      keyword ||= '.'
+      regexp = /#{keyword}/i
+      ret = load.reject do |item|
+        item.regexp = regexp
+        regexp.match(item.raw).nil?
+      end
+      ret
+    end
+
+    def print_table(data)
+      hammer.say @headers
+      ret = data.each_with_index.map do |item, index|
+        item = yield(item, index) if block_given?
+        item.to_s
+      end.join('')
+      hammer.say ret
+    end
+
+    def run(*cmds)
+      hammer.run(cmds.join(' '))
+    end
+  end
+
+  included do
+    attr_accessor :raw, :regexp
+    def to_s
+      @raw.gsub!(@regexp, '\0'.yellow) if @regexp
+      end
+
+    def run(*cmds)
+      hammer.run(cmds.join(' '))
+    end
+  end
+end

data/lib/models/container.rb

@@ -0,0 +1,75 @@
+require 'thor'
+class Container
+  include Base
+  attr_accessor :id, :image_str, :command, :created, :status, :ports, :name, :regexp_repo, :regexp_name
+  def self.command
+    'docker ps -a'
+  end
+
+  def self.find(keyword:, name:, image:)
+    return all unless keyword || name || image
+    ret = keyword ? search(keyword) : all
+    if image
+      regexp_repo = /#{image}/i
+      ret = ret.select do |container|
+        container.regexp_repo = regexp_repo
+        regexp_repo.match container.image_str
+      end
+    end
+    if name
+      regexp_name = /#{name}/i
+      ret = ret.select do |container|
+        container.regexp_name = regexp_name
+        regexp_name.match container.name
+      end
+    end
+    ret
+  end
+
+  def self.create(line)
+    id, image_str, command, created, status, ports, name = line.chomp.split(' ' * 2).reject(&:empty?).map(&:strip)
+    ret = new(
+      id: id,
+      image_str: image_str,
+      command: command,
+      created: created,
+      status: status,
+      ports: ports,
+      name: name,
+      raw: line
+    )
+    ret
+  end
+
+  def initialize(**params)
+    @id = params[:id]
+    @image_str = params[:image_str]
+    @command = params[:command]
+    @created = params[:created]
+    @status = params[:status]
+    @ports = params[:ports]
+    @name = params[:name]
+    @raw = params[:raw]
+  end
+
+  def del
+    run("docker rm -f #{id}")
+  end
+
+  def exec(exec_opts, command)
+    [
+      'docker exec',
+      exec_opts,
+      name,
+      command
+    ]
+  end
+
+  def to_s
+    @raw.gsub!(@regexp, &:yellow) if @regexp
+    @raw.sub!(/ #{image_str} /) { |_| image_str.gsub(@regexp_repo, '\0'.red) } if @regexp_repo
+    @raw.gsub!(/#{name}$/) { |name| name.gsub(@regexp_name, '\0'.blue) } if @regexp_name
+
+    @raw
+  end
+end

data/lib/models/image.rb

@@ -0,0 +1,108 @@
+class Image
+  include Base
+  attr_accessor :id, :repository, :tag, :created, :size, :regexp_repo, :regexp_tag
+  def self.headers
+    {
+      repository: 'REPOSITORY',
+      tag: 'TAG',
+      id: 'IMAGE ID',
+      created: 'CREATED',
+      size: 'SIZE'
+    }
+  end
+
+  def self.command
+    'docker images'
+  end
+
+  def self.launch(image_name, run_opts, command)
+    ['docker', 'run', run_opts, image_name, command]
+  end
+
+  def self.build(dockerfile, *tags)
+    run 'docker',
+        'build',
+        '--force-rm',
+        '-f',
+        dockerfile,
+        '-t',
+        tags.join(' -t '),
+        '.'
+  end
+
+  def self.find(keyword:, name:, tag:)
+    return all unless keyword || name || tag
+    ret = keyword ? search(keyword) : all
+    if name
+      regexp_repo = /#{name}/i
+      ret = ret.select do |image|
+        image.regexp_repo = regexp_repo
+        regexp_repo.match image.repository
+      end
+    end
+    if tag
+      regexp_tag = /#{tag}/i
+      ret = ret.select do |image|
+        image.regexp_tag = regexp_tag
+        regexp_tag.match image.tag
+      end
+    end
+    ret
+  end
+
+  def self.push(image_name)
+    run("docker push #{image_name}")
+  end
+
+  def self.create(line)
+    repository, tag, id, created, size = line.chomp.split(' ' * 2).reject(&:empty?).map(&:strip)
+    ret = new(repository: repository, tag: tag, id: id, created: created, size: size, raw: line)
+    ret
+  end
+
+  def initialize(**params)
+    @repository = params[:repository]
+    @tag = params[:tag]
+    @id = params[:id]
+    @created = params[:created]
+    @size = params[:size]
+    @raw = params[:raw]
+  end
+
+  def del
+    run("docker rmi -f #{image_name}")
+  end
+
+  def self.pull(name)
+    run("docker pull #{name}")
+  end
+
+  def push
+    self.class.push(image_name)
+  end
+
+  def self.tag(name, *as_names)
+    run("docker tag #{name} #{as_names.join(' ')}")
+  end
+
+  def image_name
+    "#{repository}:#{tag || 'latest'}"
+  end
+
+  def launch(run_opts, command)
+    self.class.launch(image_name, run_opts, command)
+  end
+
+  def to_a(*cols)
+    cols = Image.headers.keys if cols.empty?
+    ret = cols.map { |col| send(col).strip }
+    ret
+  end
+
+  def to_s
+    @raw.gsub!(@regexp, &:yellow) if @regexp
+    @raw.sub!(repository, repository.gsub(@regexp_repo, '\0'.red)) if @regexp_repo
+    @raw.gsub!(/#{tag}$/) { |tag| tag.gsub(@regexp_tag, '\0'.blue) } if @regexp_tag
+    @raw
+  end
+end

data/lib/templates/Dockerfile

@@ -0,0 +1,3 @@
+FROM '<%=@config[:base_image]%>'
+MAINTAINER <%=@config[:author]%>
+CMD <%=@config[:deamon_cmd]%>

data/lib/templates/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '2.1'
+services:
+  <%=@config[:service_name]%>:
+    image: <%=@config[:image_name]%>
+#    environment:
+#    ports:
+#    - 9191:3000
+#    links:
+#    - db:db
+#    depends_on:
+#      "db":
+#        condition: service_healthy
+#    volumes:
+#      - ../:/usr/src/app
+    command: <%=@config[:deamon_cmd]%>

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: dockerkit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- shaoyang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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: rubocop
+  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: 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: activesupport
+  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: erubis
+  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'
+description: 'dockerkit '
+email:
+- shao4phone@gmail.com
+executables:
+- dk
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/dk
+- lib/alias.yml
+- lib/concerns/constants.rb
+- lib/concerns/container_tasks.rb
+- lib/concerns/image_tasks.rb
+- lib/dockerkit.rb
+- lib/dockerkit/version.rb
+- lib/models/alias.rb
+- lib/models/base.rb
+- lib/models/container.rb
+- lib/models/image.rb
+- lib/templates/Dockerfile
+- lib/templates/docker-compose.yml
+homepage: http://github.com/yushaoyang
+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.6.11
+signing_key: 
+specification_version: 4
+summary: dockerkit
+test_files: []