docker-cli 0.3.1 → 0.5.1

data/lib/docker/cli/operations/args_parser.rb

@@ -0,0 +1,53 @@
+
+require 'toolrack'
+require_relative 'run_keep'
+require_relative 'run_del'
+require_relative 'run'
+
+module Docker
+  module Cli
+    class ArgsParser
+      include TR::ArgUtils
+
+      class ArgsParserException < StandardError; end
+
+      OpsOption = [
+        "run-keep", "rk",
+        "run-del","rd",
+        "run","r"
+      ]
+
+      arg_spec do 
+        
+        callback :pre_processing do |argv|
+          select_runner(argv)
+        end
+
+      end
+
+      def select_runner(argv)
+        ops = argv.first
+        if is_empty?(ops)
+          raise ArgsParserException, "\n Operation is empty. First parameter is operation. Supported operations including : #{OpsOption.join(", ")}\n\n"
+        else
+          case ops
+          when "run-keep", "rk" 
+            Docker::Cli::Operations::RunKeep.new.parse_argv(argv[1..-1])
+
+          when "run-del", "rd"
+            Docker::Cli::Operations::RunDel.new.parse_argv(argv[1..-1])
+
+          when "run", "r"
+            Docker::Cli::Operations::Run.new.run
+
+          else
+            raise ArgsParserException, " Unknown operation '#{ops}'. First parameter is operation. Supported operations including : #{OpsOption.join(", ")}\n" 
+          end
+        end
+
+        [true, argv[1..-1]]
+      end
+
+    end
+  end
+end

data/lib/docker/cli/operations/run.rb

@@ -0,0 +1,203 @@
+
+require 'securerandom'
+require 'tty/prompt'
+require_relative '../dockerfile'
+
+module Docker
+  module Cli
+    module Operations
+     
+      # Normal run by finding Dockerfile
+      # By default is interactive
+      class Run
+
+        def initialize
+          @pmt = TTY::Prompt.new
+        end
+
+        def run
+         
+          # find dockerfile to build an image
+          df = Dockerfile.find_available
+          raise NoDockerfileFound, "No Dockerfile found. Please create one and re-run this operation" if df.length == 0
+
+          if df.length > 1
+            @selDf = @pmt.select(" Please select one of the Dockerfile to execute : ") do |m|
+              df.each do |f|
+                m.choice f, f
+              end
+            end
+          else
+            @selDf = df.first
+          end
+
+          @mount_root = @pmt.ask(" Please provide a root for folder mount into Docker env : ", default: "/opt", required: true)
+
+          df = Dockerfile.new(@selDf)
+          # parameter pass in is to build the template
+          # e.g. docker_root is to build the dup_gem_bundler_env directive
+          ndf = df.render_dockerfile(docker_root: @mount_root)
+
+          @dev_gems = {}
+          devGems = Cli.find_dev_gems
+          if devGems.length > 0
+            devGems.each do |k,v|
+              @dev_gems[v] = File.join(@mount_root, File.basename(v))
+            end
+          end
+
+          dfName = @pmt.ask(" Please provide the new name for the generated Dockerfile : ", required: true, default: "Dockerfile.docli")
+          dfPath = File.join(Dir.getwd, dfName)
+          File.open(dfPath,"w") do |f|
+            f.write ndf
+          end
+
+          if Dockerfile.run_before?(dfPath)
+            proceed = @pmt.yes?(" Given dockerfile '#{@selDf}' seems already run before. Do you want to use existing image instead? ")
+            if proceed
+              img = Dockerfile.images(dfPath)
+              if img.length > 1
+                @selImg = @pmt.select(" There are multiple images being run from the same Dockerfile. Please select one of them : ") do |m|
+                  img.each do |i|
+                    m.choice i, i
+                  end
+                end
+              elsif img.length > 0
+                @selImg = img.first
+              end
+
+            else
+              # not using existing image.. built one
+              #@df, @selImg = build_image_from_dockerfile_bin(ndf)
+              @selImg = build_image_from_dockerfile(dfPath, dfName)
+            end
+
+          else
+            #logger.debug "Dockerfile not being run before"
+            #@df, @selImg = build_image_from_dockerfile_bin(ndf)  # => 
+            @selImg = build_image_from_dockerfile(dfPath, dfName)
+          end
+
+          logger.debug "selected image : #{@selImg}"
+
+          di = DockerImage.new(@selImg)
+          if di.has_containers?
+            if di.containers.length > 1
+              @selCont = @pmt.select(" Please select one of the container to run : ") do |m|
+
+                di.containers.each do |c|
+                  m.choice c.name_for_display, c
+                end
+
+                m.choice "New container", :new
+
+              end
+
+            else
+              @selCont = di.containers.first
+            end
+
+          end # has_containers?
+
+
+          case @selCont
+          when :new, nil
+            @selCont = @pmt.ask(" Please provide a new container name : ", required: true, default: "#{File.basename(Dir.getwd)}_#{SecureRandom.hex(4)}")
+
+            cp = ContainerProfile.new 
+            if devGems.length > 0
+              devGems.each do |name, path|
+                cp.add_mount_point(path, File.join(@mount_root, name))
+              end
+            end
+
+            # add current dir as mount point
+            cp.add_mount_point(Dir.getwd, File.join(@mount_root, File.basename(Dir.getwd)))
+
+            while true
+              STDOUT.puts "\n\n Mount points : \n"
+              ctn = 1
+              cp.mount_points.each do |local, docker|
+                STDOUT.puts " #{ctn}. #{local} ==> #{docker}"
+              end
+              apath = @pmt.ask("\n Please provide full path to mount in the docker (just enter if done) : ")
+              break if is_empty?(apath)
+
+              if File.exist?(apath)
+                mpath = @pmt.ask(" Please provide mount point inside the docker : ", default: File.dirname(apath))
+                cp.add_mount_point(mpath, File.join(@mount_root, File.basename(mpath)))
+              else
+                STDERR.puts "Given path '#{apath}' doesn't exist. Please try again."
+              end
+            end
+
+            cmd = @pmt.ask(" What command should be inside the docker? : ", required: true, default: "/bin/bash" )
+            cp.run_command = cmd
+            cp.image_name = @selImg
+
+            dc = DockerContainer.new(@selCont)
+            dc.create(cp)
+            DockerRunLog.instance.log(@selImg, @selCont)
+
+          else
+
+            #cmd = @pmt.ask(" What command should be inside the docker? : ", required: true, default: "/bin/bash" )
+            dc = DockerContainer.new(@selCont.name)
+            dc.start
+            dc.attach
+            #dc.run(cmd)
+
+          end
+
+
+        end
+
+        def build_image_from_dockerfile(df, dfName)
+
+          iName = File.basename(Dir.getwd)
+          name = @pmt.ask(" Please provide an image name for Dockerfile '#{dfName}' : ", required: true, default: "#{iName}_image") 
+          ctx = @pmt.ask(" Context to run to the dockerfile? ", required: true, default: ".")
+
+          DockerImage.build(name, dfName ,ctx)
+          DockerRunLog.instance.log_dockerfile_image(df, name)
+
+          name
+
+        end
+
+        #def build_image_from_dockerfile_bin(df)
+        #  #raise NoDockerfileFound, "Given Dockerfile to build image '#{df}' does not exist" if not File.exist?(df)
+
+        #  dfName = @pmt.ask(" Please provide the new name for the generated Dockerfile : ", required: true, default: "Dockerfile.docli")
+        #  path = File.join(Dir.getwd, dfName)
+        #  dfName = File.basename(path)
+        #  if not_empty?(df)
+        #    File.open(path,"w") do |f|
+        #      f.write df
+        #    end
+        #  end
+        # 
+        #  iName = File.basename(Dir.getwd)
+        #  name = @pmt.ask(" Please provide an image name for Dockerfile '#{dfName}' : ", required: true, default: "#{iName}_image") 
+        #  ctx = @pmt.ask(" Context to run to the dockerfile? ", required: true, default: ".")
+
+        #  DockerImage.build(name, dfName ,ctx)
+        #  DockerRunLog.instance.log_dockerfile_image(df, name)
+
+        #  [dfName, name]
+        #end
+
+
+        private
+        def logger
+          if @_logger.nil?
+            @_logger = Cli.logger(:run_ops)
+          end
+          @_logger
+        end
+
+      end
+
+    end
+  end
+end

data/lib/docker/cli/operations/run_del.rb

@@ -0,0 +1,67 @@
+
+module Docker
+  module Cli
+    module Operations
+      class RunDel
+        include TR::ArgUtils
+
+        arg_spec do
+
+          callback :pre_processing do |a|
+            capture_image(a)
+          end
+
+          opt "-c", "Command to be executed inside the Docker" do |a|
+            capture_command(a)
+          end
+
+          opt "-u", "Run as current user for Docker" do
+            set_use_same_user(true)
+          end
+
+          callback :post_processing do |a|
+            run
+          end
+
+        end
+
+        def initialize
+          @match_user = false 
+          # leave this blank as the image may have already
+          # set an entry program
+          @cmd = ""
+        end
+
+        def capture_image(a)
+          @dimage = a.first
+          [true, a[1..-1]]
+        end
+
+        def capture_command(a)
+          @cmd = a 
+        end
+
+        def set_use_same_user(bol)
+          @match_user = bol
+        end
+
+        # Just run with image name on command line
+        def run
+
+          mountLocal = Dir.getwd
+          mountDocker = "/opt/#{File.basename(Dir.getwd)}"
+          if TR::RTUtils.on_linux? and @match_user
+            # This approach has user match with local user but no name on the docker
+            # workable not nice only
+            Docker::Cli::DockerContainer.create_container(@dimage, interactive: true, tty: true, command: @cmd, mount: { mountLocal => mountDocker }, match_user: @match_user, del: true)
+          else
+            # Apparently on Mac and Windows, the user issue is not an issue
+            Docker::Cli::DockerContainer.create_container(@dimage, interactive: true, tty: true, command: @cmd, mount: { mountLocal => mountDocker }, del: true)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/docker/cli/operations/run_keep.rb

@@ -0,0 +1,118 @@
+
+require 'tty/prompt'
+require_relative '../docker_run_log'
+
+module Docker
+  module Cli
+    module Operations
+      class RunKeep
+        include TR::ArgUtils
+
+        arg_spec do
+
+          callback :pre_processing do |a|
+            capture_image(a)
+          end
+
+          opt "-c", "Command to be executed inside the Docker" do |a|
+            capture_command(a)
+          end
+
+          opt "-u", "Run as current user for Docker" do
+            set_use_same_user(true)
+          end
+
+          opt "-n", "Name of the container" do |a|
+            capture_container_name(a)
+          end
+
+          callback :post_processing do |a|
+            run
+          end
+
+        end
+
+        def initialize
+          @match_user = false #TR::RTUtils.on_linux? 
+          # leave this blank as the image may have already
+          # set an entry program
+          @cmd = ""
+        end
+
+        def capture_image(a)
+          @fullArgv = a
+          @dimage = a.first
+          [true, a[1..-1]]
+        end
+
+        def capture_command(a)
+          logger.debug "Capturing command : #{a}"
+          @cmd = a 
+        end
+
+        def capture_container_name(a)
+          @contName = a
+        end
+
+        def set_use_same_user(bol)
+          @match_user = bol
+        end
+        
+        # Just run with image name on command line
+        def run
+
+          if Docker::Cli::DockerRunLog.instance.has_existing_container?(@dimage)
+            pmt = TTY::Prompt.new
+            begin
+              eCont = pmt.select(" System found there were some container already exist on this image.\n Do you want to reuse the existing container? ") do |m|
+                DockerContainer.containers_of_image_from_history(@dimage).each do |c, name|
+                  m.choice name, c
+                end
+                m.choice "Run new container", :new_cont
+                m.choice "Quit", :quit
+              end
+
+              case eCont
+              when :new_cont
+                run_new
+              when :quit
+                STDOUT.puts " Have a nice day "
+              else
+                cont = DockerContainer.new(eCont)
+                cont.start if not cont.is_running?
+                cont.attach
+              end
+            rescue TTY::Reader::InputInterrupt
+            end
+          else
+            run_new
+          end
+
+        end
+
+        private
+        def run_new
+          mountLocal = Dir.getwd
+          mountDocker = "/opt/#{File.basename(Dir.getwd)}"
+          contName = @contName || SecureRandom.hex(18)
+          if TR::RTUtils.on_linux? and @match_user
+            # This approach has user match with local user but no name on the docker
+            # workable not nice only
+            Docker::Cli::DockerContainer.create_container(@dimage, interactive: true, tty: true, command: @cmd, mount: { mountLocal => mountDocker }, match_user: @match_user, container_name: contName)
+          else
+            # Apparently on Mac and Windows, the user issue is not an issue
+            Docker::Cli::DockerContainer.create_container(@dimage, interactive: true, tty: true, command: @cmd, mount: { mountLocal => mountDocker }, container_name: contName)
+          end
+
+          Docker::Cli::DockerRunLog.instance.log(@dimage, contName, argv: @fullArgv)
+
+        end
+
+        def logger
+          Cli.logger(:rk)
+        end
+
+      end
+    end
+  end
+end

data/lib/docker/cli/user_info.rb

@@ -0,0 +1,39 @@
+
+require 'etc'
+
+module Docker
+  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/docker/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Docker
   module Cli
-    VERSION = "0.3.1"
+    VERSION = "0.5.1"
   end
 end

data/lib/docker/cli.rb

@@ -9,9 +9,21 @@ require_relative "cli/version"
 require_relative 'cli/command'
 require_relative 'cli/command_factory'
 
+require_relative 'cli/docker_image'
+require_relative 'cli/docker_container'
+require_relative 'cli/docker_composer'
+
+require_relative 'cli/dockerfile_template'
+
 module Docker
   module Cli
+    include TR::CondUtils
+
     class Error < StandardError; end
+    class RuntimeException < StandardError; end
+    class CommandFailed < StandardError; end
+    class IndefiniteOption < StandardError; end
+    class NoDockerfileFound < StandardError; end
     # Your code goes here...
   
     def Cli.docker_exe
@@ -25,5 +37,57 @@ module Docker
 
     end
 
+    def self.find_dev_gems
+      if @_devGems.nil?
+        @_devGems = {}
+        Bundler.load.dependencies.each do |d|
+          if not d.source.nil?
+            src = d.source
+            if src.path.to_s != "."
+              @_devGems[d.name] = src.path.expand_path.to_s
+            end
+          end
+        end
+      end
+      @_devGems
+    end
+
+    def self.digest_bin(bin)
+      OpenSSL::Digest.new("SHA3-256").hexdigest(bin)
+    end
+
+    def self.command_output(out)
+      if out.is_a?(Array)
+        out.each do |e|
+          STDOUT.puts " ## #{e}"
+        end
+      else
+        STDOUT.puts " ## #{out}"
+      end
+    end
+
+    def self.logger(tag = nil, &block)
+      if @_logger.nil?
+        @_logger = TeLogger::Tlogger.new(STDOUT)
+      end
+
+      if block
+        if not_empty?(tag)
+          @_logger.with_tag(tag, &block)
+        else
+          @_logger.with_tag(@_logger.tag, &block)
+        end
+      else
+        if is_empty?(tag)
+          @_logger.tag = :docker_cli
+          @_logger
+        else
+          # no block but tag is given? hmm
+          @_logger.tag = tag
+          @_logger
+        end
+      end
+    end
+
   end
 end

data/scripts/create_user.sh.erb

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+# This is mostly a test. May not work across different variant of linux
+
+groupadd -f -g <%= user_group_id %>  <%= user_group_name %> && useradd -u <%= user_id %> -g <%= user_group_id %> -m <%= user_login %> && usermod -aG sudo <%= user_login %> && echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers
+
+tail -f /dev/null
+#while true; do sleep 1000; done
+#exec /bin/bash
+