dockerun 0.3.6 → 0.4.0

data/lib/dockerun/cli/command_factory.rb

@@ -0,0 +1,313 @@
+
+require 'erb'
+
+require_relative 'command'
+require_relative 'user_info'
+
+module Dockerun
+  module Cli
+    class CommandFactory
+      include TR::CondUtils
+
+      def build_image(name = "", opts = {  }, &block)
+
+        opts = {  } if opts.nil?
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "build"
+        if not_empty?(name)
+          cmd << "-t #{name}"
+        end
+
+        if not_empty?(opts[:dockerfile])
+          cmd << "-f #{opts[:dockerfile]}"
+        end
+
+        root = opts[:context_root]
+        root = "." if is_empty?(root)
+        cmd << root
+
+        logger.debug "Build Image : #{cmd.join(" ")}"
+        Command.new(cmd)
+
+      end # build_image
+
+
+      def find_image(name, tag = "", opts = { })
+        name = "" if name.nil?
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "images"
+        cmd << "-q"
+        if not_empty?(tag)
+          cmd << "#{name}:#{tag}"
+        else
+          cmd << name
+        end
+
+        logger.debug "Find image: #{cmd.join(" ")}"
+
+        Command.new(cmd)
+      end # find_image
+
+      def delete_image(name, tag = "", opts = { })
+
+        if not_empty?(name)
+
+          cmd = []
+          cmd << DockerCli.docker_exe
+          cmd << "rmi"
+          if not_empty?(tag)
+            cmd << "#{name}:#{tag}"
+          else
+            cmd << name
+          end
+
+          logger.debug "Delete image: #{cmd.join(" ")}"
+          Command.new(cmd)
+
+        else
+          raise Error, "Name is required for delete operation"
+        end
+
+      end # delete_image
+
+
+      def find_running_container(name, opts = { })
+
+        raise Error, "Name is mandatory" if is_empty?(name)     
+
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "ps"
+        cmd << "-q"
+        cmd << "-f"
+        cmd << "name=\"#{name}\""
+
+        logger.debug "Find container: #{cmd.join(" ")}"
+
+        Command.new(cmd)
+       
+      end
+
+      # Find from container even if it is already stopped
+      def find_from_all_container(name, opts = { })
+        raise Error, "Name is required" if is_empty?(name)     
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "ps"
+        # return all info instead of only the container ID
+        #cmd << "-a"
+        cmd << "-aq"
+        cmd << "-f"
+        # From little testing seems the command by default already support regex formatting
+        # So can use the regex marker to get exact match
+        # e.g. if want exact match, pass in ^#{name}\z
+        cmd << "name=\"#{name}\""
+
+        logger.debug "Find from all container: #{cmd.join(" ")}"
+        Command.new(cmd)
+      end
+
+
+      def find_container_names_by_image_name(image_name, opts = { })
+
+        raise Error, "Image name is mandatory" if is_empty?(image_name)     
+
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "ps"
+        cmd << "-a" if opts[:all_containers] == true
+        cmd << "-f"
+        cmd << "ancestor=\"#{image_name}\""
+        cmd << "--format \"{{.Names}}\""
+
+        logger.debug "Find container by image name: #{cmd.join(" ")}"
+
+        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 = []
+        cmd << DockerCli.docker_exe
+        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]}\""
+        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])
+          cmd << "\"#{opts[:command]}\""
+        end
+
+        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
+
+      def start_container(container, opts = { })
+
+        opts = {} if opts.nil?
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "container"
+        cmd << "start"
+        cmd << container
+
+        logger.debug "Start Container : #{cmd.join(" ")}"
+        Command.new(cmd)
+      end
+
+      def attach_container(container, opts = { })
+
+        opts = {} if opts.nil?
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "container"
+        cmd << "attach"
+        cmd << container
+
+        logger.debug "Attach Container : #{cmd.join(" ")}"
+        # this is a bit difficult to juggle 
+        # it depending on the previous docker configuration
+        # but to be save, just open up a new terminal
+        Command.new(cmd, true)
+      end
+      
+      
+      def stop_container(container, opts = { })
+
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "container"
+        cmd << "stop"
+        cmd << container
+
+        logger.debug "Stop Container : #{cmd.join(" ")}"
+        Command.new(cmd)
+      end
+
+      
+      def delete_container(container, opts = { })
+
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "container"
+        cmd << "rm"
+        cmd << container
+
+        logger.debug "Delete Container : #{cmd.join(" ")}"
+        Command.new(cmd)
+      end
+
+
+      def run_command_in_running_container(container, command, opts = {  })
+        cmd = []
+        cmd << DockerCli.docker_exe
+        cmd << "container"
+        cmd << "exec"
+
+        isTty = false
+        isInteractive = false
+        if not_empty?(opts[:tty]) and opts[:tty] == true
+          cmd << "-t" 
+          isTty = true
+        end
+        if not_empty?(opts[:interactive]) and opts[:interactive] == true
+          cmd << "-i" 
+          isInteractive = true
+        end
+
+        cmd << container
+
+        if is_empty?(command)
+          cmd << "/bin/bash --login"
+        else
+          cmd << command
+        end
+
+        logger.debug "Run command in running container : #{cmd.join(" ")}"
+        Command.new(cmd, ((isTty or isInteractive) ? true : false))
+      end # container_prompt
+
+
+      private
+      # expecting :mounts => { "/dir/local" => "/dir/inside/docker" }
+      def process_mount(opts)
+        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
+        else
+          ""
+        end
+        
+      end # process_mount
+
+      def process_port(opts)
+         if not_empty?(opts[:ports]) #not (opts[:ports].nil? or opts[:ports].empty?)
+          po = opts[:ports]
+          res = []
+          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
+          ""
+        end
+        
+      end
+
+      def logger
+        Dockerun.logger(:cmdFact)
+      end
+
+      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
+  end
+end

data/lib/dockerun/cli/command_result.rb

@@ -0,0 +1,67 @@
+
+require 'toolrack'
+
+module Dockerun
+
+  module Cli
+    
+    class CommandResult
+      include TR::CondUtils
+
+      attr_reader :out, :err, :result
+      def initialize(result, out, err)
+        @result = result
+        @out = out
+        @err = err
+      end
+
+      def is_out_stream_empty?
+        is_empty?(@out)
+      end
+
+      def is_err_stream_empty?
+        is_empty?(@err)
+      end
+
+      def out_stream
+        @out.join("\n") 
+      end
+
+      def err_stream
+        @err.join("\n")
+      end
+
+      def failed?
+        if @result.nil?
+          true
+        else
+          @result.failed?
+        end
+      end
+
+      def success?
+        not failed?
+      end
+      alias_method :successful?, :success?
+
+      def each_output_line(&block)
+        out_stream.each_line(&block)
+      end
+
+      def each_err_lines(&block)
+        err_stream.each_line(&block)
+      end
+
+      def output_lines
+        out_stream.lines
+      end
+
+      def err_lines
+        err_stream.lines
+      end
+
+    end
+
+  end
+  
+end

data/lib/dockerun/cli/delete_container.rb

@@ -0,0 +1,55 @@
+
+require_relative 'command_factory'
+
+module Dockerun
+  module Cli
+    class DSLProxy
+      include DSL
+    end
+
+    class DeleteContainer
+
+      def start
+        begin
+          pmt.puts " Dockerun version #{Dockerun::VERSION}".yellow
+          pmt.puts " Operational : Delete Container"
+          delete_container
+        rescue TTY::Reader::InputInterrupt
+        end
+      end
+
+      def delete_container
+        selSpec = CliEngine.select_spec
+        cont = File.read(selSpec)
+        proxy = DSLProxy.new
+        proxy.set_dry_run_mode
+        proxy.instance_eval(cont)
+
+        skip = pmt.no?(" Delete container named '#{proxy.container_name}'?")
+        if not skip
+          cf.stop_container(proxy.container_name).run
+          res = cf.delete_container(proxy.container_name).run
+          if res.success?
+            pmt.puts " Container '#{proxy.container_name}' deleted".green
+          else
+            pmt.puts " Container '#{proxy.container_name}' deletion failed. Error was : #{res.err_lines.join("\n")}".red
+          end
+        else
+          pmt.puts " Container deletion of name '#{proxy.container_name}' aborted.".yellow
+        end
+      end
+
+      def pmt
+        CliEngine.pmt
+      end
+
+      def cf
+        if @_cf.nil?
+          @_cf = CommandFactory.new
+        end
+        @_cf
+      end
+
+    end
+  end
+end

data/lib/dockerun/cli/delete_image.rb

@@ -0,0 +1,99 @@
+
+require_relative 'command_factory'
+
+module Dockerun
+  module Cli
+    class DSLProxy
+      include DSL
+    end
+
+    class DeleteImage
+      include TR::CondUtils
+
+      def start
+        begin
+          pmt.puts " Dockerun version #{Dockerun::VERSION}".yellow
+          pmt.puts " Operational : Delete Image"
+          delete_image
+        rescue TTY::Reader::InputInterrupt
+        end
+      end
+
+      def delete_image
+        selSpec = CliEngine.select_spec
+        cont = File.read(selSpec)
+        proxy = DSLProxy.new
+        proxy.set_dry_run_mode
+        proxy.instance_eval(cont)
+
+        res = cf.find_image(proxy.image_name).run
+        if res.success?
+          if not_empty?(res.output_lines)
+
+            skip = pmt.no?(" Delete image named '#{proxy.image_name}'?")
+            if not skip
+              res = cf.find_container_names_by_image_name(proxy.image_name, all_containers: true).run
+              raise Error, "Failed to extract container name by image name '#{proxy.image_name}'" if not res.success?
+
+              if not_empty?(res.output_lines)
+                cont = []
+                cnt = 0
+                res.output_lines.each do |l|
+                  cont << " #{cnt += 1}. #{l}"
+                end
+                skip = pmt.no?(" All the containers shall be deleted prior to image '#{proxy.image_name}' deletion. Proceed?\n#{cont.join("\n")}")
+                if not skip
+                  res.output_lines.each do |ci|
+                    cf.stop_container(ci).run
+                    cf.delete_container(ci).run
+                  end
+
+                  res = cf.delete_image(proxy.image_name).run
+                  if res.success?
+                    pmt.puts " Image '#{proxy.image_name}' deleted".green
+                  else
+                    raise Error, " Image '#{proxy.image_name}' deletion failed. Error was : #{res.err_lines.join("\n")}"
+                  end
+
+                else
+                  pmt.puts " Delete of image '#{proxy.image_name}' aborted".yellow
+                end
+
+              else
+                res = cf.delete_image(proxy.image_name).run
+                if res.success?
+                  pmt.puts " Image '#{proxy.image_name}' deleted".green
+                else
+                  raise Error, " Image '#{proxy.image_name}' deletion failed. Error was : #{res.err_lines.join("\n")}"
+                end
+
+              end
+
+            else
+              pmt.puts " Delete of image '#{proxy.image_name}' aborted".yellow
+
+            end
+
+          else
+            pmt.puts " Image '#{proxy.image_name}' does not exist".green
+          end
+
+        else
+          pmt.puts " Failed to find image '#{proxy.image_name}'. Error was : #{res.err_lines.join("\n")}"
+        end
+      end
+
+      def pmt
+        CliEngine.pmt
+      end
+
+      def cf
+        if @_cf.nil?
+          @_cf = CommandFactory.new
+        end
+        @_cf
+      end
+
+    end
+  end
+end

data/lib/dockerun/cli/run.rb

@@ -0,0 +1,39 @@
+
+require 'tty/prompt'
+require 'colorize'
+
+module Dockerun
+  module Cli
+    class Run
+      #include TR::ArgUtils
+      include DSL
+
+      def start
+        begin
+          pmt.puts " Dockerun version #{Dockerun::VERSION}".yellow
+          pmt.puts " Operational : Run Spec"
+          load_spec
+        rescue TTY::Reader::InputInterrupt
+        end
+      end
+
+
+      private
+      def load_spec
+        selSpec = CliEngine.select_spec
+        pmt.puts " Loading spec '#{selSpec}"
+        cont = File.read(selSpec)
+        self.instance_eval(cont)
+        go if not is_go_done?
+      end
+
+      def pmt
+        if @_pmt.nil?
+          @_pmt = TTY::Prompt.new
+        end
+        @_pmt
+      end
+
+    end
+  end
+end

data/lib/dockerun/cli/user_info.rb

@@ -0,0 +1,39 @@
+
+require 'etc'
+
+module Dockerun
+  module Cli
+
+    module UserInfo
+      include TR::CondUtils
+
+      def self.user_info(login = nil)
+        login = Etc.getlogin if is_empty?(login)
+        res = { login: login }
+        begin
+          res[:uid] = Etc.getpwnam(login).uid
+        rescue Exception => ex
+          res[:uid] = nil
+        end
+        res
+      end
+
+      def self.group_info(login = nil)
+        login = Etc.getlogin if is_empty?(login)
+        res = {  }
+        begin
+          gnm = Etc.getgrnam(login)
+          res[:group_name] = gnm.name
+          res[:gid] = gnm.gid
+        rescue Exception => ex
+          p ex
+          res[:group_name] = ""
+          res[:gid] = nil
+        end
+        res
+      end
+
+    end
+  end
+
+end

data/lib/dockerun/cli_engine.rb

@@ -0,0 +1,104 @@
+
+require 'tty/prompt'
+require_relative 'cli/run'
+require_relative 'cli/delete_container'
+require_relative 'cli/delete_image'
+
+module Dockerun
+  class CliEngine
+    include TR::ArgUtils
+
+    arg_spec do
+      opt "i", "Initialize sample dockerspec at current directory" do
+        init
+      end
+      opt_alias "i", "init"
+
+      opt "r", "Run the dockerspec" do 
+        run
+      end
+      opt_alias "r","run"
+
+      opt "dc", "Delete container" do
+        delete_container
+      end
+
+      opt "di", "Delete image and its associated container(s)" do
+        delete_image
+      end
+
+      opt 'clean', "Clean generated Dockerfile and temporary files" do
+        clean_env
+      end
+
+      opt 'help', "Command help" do
+        print_help
+      end
+
+    end
+
+    def print_help
+      pmt = self.class.pmt
+      pmt.puts ""
+      pmt.puts " Dockerun version #{Dockerun::VERSION}".magenta
+      pmt.puts ""
+      pmt.puts " Supported options : "
+      self.class.arg_options.each do |key, val|
+        pmt.puts " #{key}\t\t#{val[:desc]}"
+      end
+      pmt.puts ""
+    end
+
+    def self.select_spec
+      sel = Dir.entries(Dir.getwd).sort
+      default = sel.select { |e| (e =~ /^dockerspec/) != nil }
+      selSpec = pmt.select(" Please select the dockerspec to proceed : ", filter: true, default: default.first) do |m|
+        sel.each do |s|
+          next if sel == "." or sel == ".." or File.directory?(s)
+          m.choice s, File.expand_path(s)
+        end
+      end
+
+      selSpec
+    end
+
+
+    def init
+      template = File.join(File.dirname(__FILE__),"..","..","dockerspec.sample")        
+      if File.exist?(template)
+        FileUtils.cp template, File.join(Dir.getwd, "dockerspec.sample")
+      end
+    end
+
+    def run
+      r = Dockerun::Cli::Run.new
+      r.start
+    end
+
+    def delete_container
+      d = Dockerun::Cli::DeleteContainer.new
+      d.start
+    end
+
+    def delete_image
+      d = Dockerun::Cli::DeleteImage.new
+      d.start
+    end
+
+    def clean_env
+      Dir.glob("Dockerfile-*").each do |f|
+        FileUtils.rm(f)
+      end
+      FileUtils.rm("script_for_gem.sh") if File.exist?("script_for_gem.sh")
+      self.class.pmt.puts " Generated Dockerfile-* and script_for_gem.sh is deleted".green
+    end
+
+    def self.pmt
+      if @_pmt.nil?
+        @_pmt = TTY::Prompt.new
+      end
+      @_pmt
+    end
+
+  end
+end