docker-cli 0.3.1 → 0.5.0

data/lib/docker/cli/command_factory.rb

@@ -1,12 +1,15 @@
 
+require 'erb'
+
 require_relative 'command'
+require_relative 'user_info'
 
 module Docker
   module Cli
     class CommandFactory
       include TR::CondUtils
 
-      def build_image(name = "", opts = {  })
+      def build_image(name = "", opts = {  }, &block)
 
         opts = {  } if opts.nil?
         cmd = []
@@ -37,9 +40,9 @@ module Docker
         cmd << "images"
         cmd << "-q"
         if not_empty?(tag)
-          cmd << "#{name}:#{tag}"
+          cmd << "\"#{name}:#{tag}\""
         else
-          cmd << name
+          cmd << "\"#{name}\""
         end
 
         logger.debug "Find image: #{cmd.join(" ")}"
@@ -106,6 +109,10 @@ module Docker
         Command.new(cmd)
       end
 
+      # 
+      # Create container from image directly
+      # e.g. > docker run -it <image> "/bin/bash"
+      #
       def create_container_from_image(image, opts = { })
         opts = {} if opts.nil?
         cmd = []
@@ -113,13 +120,21 @@ module Docker
         cmd << "run"
         cmd << "-i" if opts[:interactive] == true
         cmd << "-t" if opts[:tty] == true
+        cmd << "-d" if opts[:detached] == true
+        cmd << "--rm" if opts[:del] == true
         if not (opts[:container_name].nil? or opts[:container_name].empty?)
-          cmd << "--name #{opts[:container_name]}"
+          cmd << "--name \"#{opts[:container_name]}\""
         end
 
         cmd << process_mount(opts)
         cmd << process_port(opts)
 
+        if opts[:match_user] == true
+          ui = UserInfo.user_info
+          gi = UserInfo.group_info
+          cmd << "-u #{ui[:uid]}:#{gi[:gid]}"
+        end
+
         cmd << image
 
         if not_empty?(opts[:command])
@@ -128,7 +143,7 @@ module Docker
 
         interactive = false
         interactive = true if opts[:interactive] or opts[:tty]
-        
+
         logger.debug "Run Container from Image : #{cmd.join(" ")}"
         Command.new(cmd, (interactive ? true : false))
       end # run_container_from_image
@@ -220,17 +235,17 @@ module Docker
 
 
       private
-      # expecting :mounts => [{ "/dir/local" => "/dir/inside/docker" }]
+      # expecting :mounts => { "/dir/local" => "/dir/inside/docker" }
       def process_mount(opts)
-        if not (opts[:mount].nil? or opts[:mount].empty?)
-          m = opts[:mount]
-          m = [m] if not m.is_a?(Array)
-          res = []
-          m.each do |mm|
-            host = mm.keys.first
-            res << "-v #{host}:#{mm[host]}"
+        if not_empty?(opts[:mounts]) #not (opts[:mounts].nil? or opts[:mounts].empty?)
+          m = opts[:mounts]
+          if m.is_a?(Hash)
+            res = []
+            m.each do |local, docker|
+              res << "-v #{local}:#{docker}"
+            end
+            res.join(" ")
           end
-          res.join(" ")
         else
           ""
         end
@@ -238,13 +253,20 @@ module Docker
       end # process_mount
 
       def process_port(opts)
-         if not (opts[:ports].nil? or opts[:ports].empty?)
+         if not_empty?(opts[:ports]) #not (opts[:ports].nil? or opts[:ports].empty?)
           po = opts[:ports]
-          po = [po] if not po.is_a?(Array)
           res = []
-          po.each do |host,docker|
-            res << "-p #{host}:#{docker}"
+          if po.is_a?(Hash)
+            po.each do |host, docker|
+              res << "-p #{host}:#{docker}"
+            end
           end
+          #po = [po] if not po.is_a?(Array)
+          #po.each do |e|
+          #  # 1st is port on host
+          #  # 2nd is port inside container
+          #  res << "-p #{e.keys.first}:#{e.values.first}"
+          #end
           res.join(" ")
         else
           ""
@@ -253,15 +275,17 @@ module Docker
       end
 
       def logger
-        if @logger.nil?
-          @logger = TeLogger::Tlogger.new
-          @logger.tag = :docker_cmd
-        end
-        @logger
+        Cli.logger(:cmdFact)
       end
 
-      def parse_container_list(out, &block)
-         
+      def build_add_user_script
+        path = File.join(File.dirname(__FILE__),"..","..","..","scripts","create_user.sh.erb")
+        if File.exist?(path)
+          ui = UserInfo.user_info
+          gi = UserInfo.group_info
+
+          ERB.new(File.read(path)).result_with_hash({ user_group_id: gi[:gid], user_group_name: gi[:group_name], user_id: ui[:uid], user_login: ui[:login] })
+        end
       end
 
     end

data/lib/docker/cli/command_result.rb

@@ -19,6 +19,10 @@ module Docker
         is_empty?(@out)
       end
 
+      def is_err_stream_empty?
+        is_empty?(@err)
+      end
+
       def out_stream
         @out.join("\n") 
       end
@@ -35,6 +39,18 @@ module Docker
         end
       end
 
+      def success?
+        not failed?
+      end
+      alias_method :successful?, :success?
+
+      def each_line(&block)
+        out_stream.each_line(&block)
+      end
+
+      def lines
+        out_stream.lines
+      end
     end
 
   end

data/lib/docker/cli/docker_composer.rb

@@ -0,0 +1,113 @@
+
+require 'yaml'
+
+require_relative 'user_info'
+
+module Docker
+  module Cli
+    class DockerComposer
+      include TR::CondUtils
+      include TR::ArgUtils
+
+      arg_spec do
+
+        callback :pre_processing do |a|
+          parse_input(a)
+        end
+
+      end
+
+      def parse_input(argv, &block)
+        @dcPath = argv.first
+        @dcPath = "./docker-compose.yml" if is_empty?(@dcPath) 
+        @dcPath = "./docker-compose.yaml" if not File.exist?(@dcPath)
+        raise RuntimeException, "docker-compose.[yml,yaml] not found. Please provide the docker-compose.yml file to load" if not File.exist?(@dcPath)
+
+        @outPath = argv[1]
+        @outPath = "#{@dcPath}-gen.yml" if is_empty?(@outPath)
+
+        process_dc
+
+        [true, []]
+      end
+
+      def process_dc
+        if File.exist?(@dcPath)
+
+          cont = YAML.safe_load(File.read(@dcPath))
+
+          if not_empty?(cont["services"])
+
+            cont["services"].each do |servName, conf|
+
+              # if user key is empty, match with current uid and gid
+              if conf.keys.include?("user") and is_empty?(conf["user"])
+                conf["user"] = "#{user_info[:uid]}:#{user_group_info[:gid]}"
+              end
+
+              # add to volumes if there is development gems found
+              if not_empty?(conf["volumes"])
+                vol = conf["volumes"]
+
+                if vol.include?("devgems")
+
+                  vol.delete("devgems")
+                  logger.debug "Volume after delete : #{vol.inspect}"
+
+                  devGems = Cli.find_dev_gems
+                  logger.debug " Found #{devGems.length} devgems"
+                  if devGems.length > 0
+                    if @parse_argv_block
+                      @mount_root = @parse_argv_block.call(:prompt_docker_mount_root)
+                    else
+                      raise RuntimeException, "Please provide a block to prompt for missing parameters"
+                    end
+
+                    devGems.each do |name,path|
+                      vol << "#{path}:#{File.join(@mount_root, name)}"
+                    end
+                  end
+
+                end
+
+              end
+            end
+
+          end
+
+          reCont = cont.to_yaml
+          reCont = reCont.gsub("---","")
+          File.open(@outPath, "w") do |f|
+            f.write reCont
+          end
+
+        else
+          raise RuntimeException, "Given docker compose file '#{@dcPath}' does not exist"
+        end
+      end
+
+      private
+      def user_info
+        if @_user_info.nil?
+          @_user_info = UserInfo.user_info
+        end
+        @_user_info
+      end
+
+      def user_group_info
+        if @_userg_info.nil?
+          @_userg_info = UserInfo.group_info
+        end
+        @_userg_info
+      end
+
+      def logger
+        if @_logger.nil?
+          @_logger = Cli.logger(:docomp)
+        end
+        @_logger
+      end
+
+    end
+  end
+end

data/lib/docker/cli/docker_container.rb

@@ -0,0 +1,216 @@
+
+require_relative 'command_factory'
+
+module Docker
+  module Cli
+
+    # only use during creation of new container
+    class ContainerProfile
+      include TR::CondUtils
+
+      attr_accessor :run_command, :image_name
+      def initialize
+        @interactive = true
+        @run_detached = false
+        @remove_after_run = false
+        @match_user = false
+        @run_command = "/bin/bash"
+        @mounts = {}
+        @ports = {}
+      end
+
+      def mount_points
+        @mounts.freeze
+      end
+      def add_mount_point(host, inside_docker)
+        if not_empty?(host) and not_empty?(inside_docker)
+          @mounts[host] = inside_docker
+        end
+      end
+
+      def ports
+        @ports.freeze
+      end
+      def add_port_mapping(host, docker)
+        if not_empty?(host) and not_empty?(docker)
+          @ports[host] = docker
+        end
+      end
+
+      def is_interactive?
+        @interactive
+      end
+      def interactive=(val)
+        @interactive = val
+      end
+
+      def is_run_detached?
+        @run_detached
+      end
+      def run_detached=(val)
+        @run_detached = val
+      end
+
+      def remove_after_run?
+        @remove_after_run
+      end
+      def remove_after_run=(val)
+        @remove_after_run = val 
+      end
+
+      def is_match_user?
+        @match_user
+      end
+      def match_user=(val)
+        @match_user = val
+      end
+
+      def to_hash
+        # this returns a hash that match expectation of input in CommandFactory.create_container_from_image
+        { interactive: @interactive, tty: @interactive, detached: @run_detached, del: @remove_after_run, mounts: @mounts, ports: @ports, match_user: @match_user, command: @run_command }
+      end
+
+    end # class NewContainerProfile
+
+    class DockerContainer
+      include TR::CondUtils
+
+      #def self.is_exists?(name)
+      #  res = command.find_from_all_container(name, opts).run 
+      #  raise CommandFailed, "Command to check if container exist failed. Error was : #{res.err_stream}" if not res.successful?
+      #  not res.is_out_stream_empty?
+      #end
+
+      #def self.create(image, opts = {}, &block)
+      #  command.create_container_from_image(image, opts).run
+      #end
+
+      #def self.prep_container(image, opts = {})
+      #  # render the create_user script
+      #  res = build_add_user_script
+      #  # system always mount current dir inside docker
+      #  dest = File.join(opts[:mount_local],"create_user.sh")
+      #  File.open(dest,"w") do |f|
+      #    f.write res
+      #  end
+      #  `chmod +x #{dest}`
+
+      #  # create non interactive session to create the user & group first
+      #  opts[:command] = "#{File.join(opts[:mount_docker],"create_user.sh")}"
+      #  opts[:detached] = true
+      #  command.create_container_from_image(image, opts).run
+      #end
+
+      def self.containers_of_image_from_history(img, opts = {  })
+        cont = DockerRunLog.instance.containers(img)
+        res = {}
+        if cont.length == 1
+          c = cont.first
+          res[c[:container]] = c
+        else
+          cont.each do |c|
+            res[c[:container]] = "#{c[:container]} [Last Access : #{Time.at(c[:last_run])}] - Config : #{c[:argv]}"
+          end
+          res
+        end
+      end
+
+      #def self.containers(image = nil)
+      #  
+      #end
+
+      #def self.container(name)
+      #  
+      #end
+
+      attr_reader :name
+
+      def initialize(name, history = nil)
+        @name = name
+        @history = history
+      end
+
+      def is_exist?
+        res = command.find_from_all_container(@name).run 
+        raise CommandFailed, "Command to check if container exist failed. Error was : #{res.err_stream}" if not res.successful?
+        not res.is_out_stream_empty?
+      end
+
+      def create(container_profile)
+        raise CommandFailed, " Image name is not given to create the container '#{@name}'" if is_empty?(container_profile.image_name)
+        opts = container_profile.to_hash
+        opts[:container_name] = @name
+        command.create_container_from_image(container_profile.image_name, opts).run
+      end
+
+      def name_for_display
+        if @history.nil?
+          @name
+        else
+          "#{@history[:container]} [Last Access : #{Time.at(@history[:last_run])}] - Config : #{@history[:argv]}"
+        end
+      end
+
+      def run_before?
+        not @history.nil?
+      end
+
+      def history
+        if not @history.nil?
+          @history.freeze
+        else
+          @history = {}
+        end
+      end
+
+      def is_running?
+        res = command.find_running_container(@name).run
+        raise CommandFailed, "Command to find running container failed. Error was : #{res.err_stream}" if not res.successful?
+        not res.is_out_stream_empty?
+      end
+
+      def start(&block)
+        command.start_container(@name).run
+      end
+
+      def stop(&block)
+        command.stop_container(@name).run
+      end
+
+      def attach(&block)
+        command.attach_container(@name).run
+      end
+
+      def delete!(&block)
+        command.delete_container(@name).run
+      end
+
+      def run(cmd, opts = {}, &block)
+        command.run_command_in_running_container(@name, cmd, opts).run 
+      end
+
+      private
+      def self.command
+        if @_cmd.nil?
+          @_cmd = CommandFactory.new
+        end
+        @_cmd
+      end
+
+      def command
+        self.class.command
+      end
+
+      def self.build_add_user_script
+        path = File.join(File.dirname(__FILE__),"..","..","..","scripts","create_user.sh.erb")
+        if File.exist?(path)
+          ui = UserInfo.user_info
+          gi = UserInfo.group_info
+
+          ERB.new(File.read(path)).result_with_hash({ user_group_id: gi[:gid], user_group_name: gi[:group_name], user_id: ui[:uid], user_login: ui[:login] })
+        end
+      end
+      
+    end
+  end
+end

data/lib/docker/cli/docker_image.rb

@@ -0,0 +1,205 @@
+
+require_relative 'command_factory'
+
+module Docker
+  module Cli
+    class DockerImage
+      include TR::CondUtils
+
+      def self.set_master_format(format)
+        @_doc_mformat = format
+      end
+      def self.master_format
+        if @_doc_mformat.nil?
+          @_doc_mformat = "{{.Repository}}#{self.separator}{{.ID}}#{self.separator}{{.Tag}}"
+        end
+        @_doc_mformat.freeze
+      end
+
+      def self.set_inspect_format(format)
+        @_dec_iformat = format
+      end
+      def self.inspect_format
+        if @_doc_iformat.nil?
+          @_doc_iformat = "{{.Created}}#{self.separator}{{.Size}}"
+        end
+        @_doc_iformat.freeze
+      end
+
+      def self.set_separator(sep)
+        @_doc_sep = sep
+      end
+      def self.separator
+        if @_doc_sep.nil?
+          @_doc_sep = ";"
+        end
+        @_doc_sep.freeze
+      end
+
+      def self.images
+        logger.warn "loading images from system is an expensive operation. Please implement some cache at aplication level to increase its efficiency"
+        cmd = []
+        cmd << Cli.docker_exe
+        cmd << "images"
+        cmd << "--format"
+        cmd << "\"#{self.master_format}\""
+
+        rres = []
+        res = Command.new(cmd).run
+        if res.successful?
+          res.each_line do |l|
+            sp = l.strip.split(self.separator)
+            rres << { name: sp[0], id: sp[1], tag: sp[2] }
+          end
+        else
+          logger.warn "Command '#{cmd.join(" ")}' failed.\n Error was : #{res.err_stream}"
+        end
+
+        fres = []
+        rres.each do |r|
+          ccmd = []
+          ccmd << cmd[0]
+          ccmd << "inspect"
+          ccmd << "-f"
+          ccmd << "'{{.ID}}#{self.separator}{{.Created}}#{self.separator}{{.Size}}'"
+          ccmd << r[:name]
+
+          rres = Command.new(ccmd).run
+          if rres.successful?
+            rres.each_line do |l|
+              sp = l.strip.split(self.separator)
+              rid = sp[0]
+              r[:image_id] = rid.split(":")[1]
+              r[:created] = sp[1]
+              r[:size] = sp[2]
+              r[:runtime] = true
+              fres << DockerImage.new(r[:name], r)
+            end
+          else
+            logger.warn "Command '#{ccmd.join(" ")}' failed.\n Error was : #{rres.err_stream}"
+          end
+        end
+
+        fres
+      end
+
+      def self.image(image)
+        cmd = []
+        cmd << Cli.docker_exe
+        cmd << "images"
+        cmd << "--format"
+        cmd << "\"#{self.master_format}\""
+        # image and tag is in single unit
+        # e.g.:
+        # jruby:9.2-jdk11
+        # jruby:9
+        # jruby:9.3.0.0-jdk11
+        cmd << image
+
+        rres = []
+        res = Command.new(cmd).run
+        if res.successful?
+          # single image could have many lines because they have 
+          # different tags!
+          res.each_line do |l|
+            sp = l.strip.split(self.separator)
+            rres << { name: sp[0], id: sp[1], tag: sp[2] }
+          end
+        else
+          logger.warn "Command '#{cmd.join(" ")}' failed.\n Error was : #{res.err_stream}"
+        end
+
+        fres = []
+        rres.each do |r|
+          ccmd = []
+          ccmd << cmd[0]
+          ccmd << "inspect"
+          ccmd << "-f"
+          ccmd << "'{{.ID}}#{self.separator}{{.Created}}#{self.separator}{{.Size}}'"
+          ccmd << r[:name]
+
+          rres = Command.new(ccmd).run
+          if rres.successful?
+            rres.each_line do |l|
+              sp = l.strip.split(self.separator)
+              rid = sp[0]
+              r[:image_id] = rid.split(":")[1]
+              r[:created] = sp[1]
+              r[:size] = sp[2]
+              r[:runtime] = true
+              fres << DockerImage.new(r[:name], r)
+            end
+          else
+            logger.warn "Command '#{ccmd.join(" ")}' failed.\n Error was : #{rres.err_stream}"
+          end
+        end
+
+        fres
+      end
+
+      def self.build(imageName, dockerfile, context = ".")
+        command.build_image(imageName, dockerfile: dockerfile, context_root: context).run
+      end
+
+
+      attr_reader :name, :tag, :size, :created, :image_id, :sid
+
+      def initialize(name, opts = {})
+        @name = name
+        if not_empty?(opts)
+          @sid = opts[:sid]
+          @image_id = opts[:image_id]
+          @tag = opts[:tag]
+          @size = opts[:size]
+          @created = opts[:created]
+          @runtime = opts[:runtime]
+        end
+
+        @runtime = false if is_empty?(@runtime) or not_bool?(@runtime)
+
+      end
+
+      def is_runtime_image?
+        @runtime
+      end
+
+      def has_containers?
+        DockerRunLog.instance.image_has_containers?(@name)
+      end
+
+      def containers
+        if @_cont.nil?
+          # here assuming every run from system will be logged
+          # but what about the one not using the system?
+          @_cont = DockerRunLog.instance.image_containers(@name).collect { |e| DockerContainer.new(e[:container], e) }
+        end
+        @_cont
+      end
+
+      def delete!
+        if not_empty?(@tag)
+          command.delete_image(@name, @tag, opts)
+        else
+          raise IndefiniteOption, "Delete image cannot proceed because there might be more than single instance of the image. Please provide a tag for definite selection for deletion." 
+        end
+      end
+
+      private
+      def self.command
+        if @_cmd.nil?
+          @_cmd = CommandFactory.new
+        end
+        @_cmd
+      end
+
+      def command
+        self.class.command
+      end
+
+      def self.logger
+        Cli.logger(:docker_image)
+      end
+
+    end
+  end
+end