docker-cli 0.3.0 → 0.5.0

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

data/lib/docker/cli/docker_run_log.rb

@@ -0,0 +1,169 @@
+
+require 'singleton'
+require 'yaml'
+
+module Docker
+  module Cli
+
+    class NonEmptyRecord < StandardError; end
+
+    class DockerRunLog
+      include TR::CondUtils
+      include Singleton
+
+      def log(image, container, opts = {})
+        if not_empty?(image) and not_empty?(container)
+          logfile[image] = [] if logfile[image].nil?
+          cont = { container: container, created_at: Time.now.to_i, last_run: Time.now.to_i } 
+          cont = cont.merge(opts) if not_empty?(opts)
+          logfile[image] << cont
+          write
+        end
+      end
+
+      #def log_dockerfile(df)
+      #  if not_empty?(df) and File.exist?(df) 
+      #    logfile[:dockerfile_signature] = [] if logfile[:dockerfile_signature].nil?
+      #    d = digest_file(df)
+      #    if not logfile[:dockerfile_signature].include?(d)
+      #      logfile[:dockerfile_signature] << digest.hexdigest(File.read(df))
+      #    end
+      #    write
+      #  end
+      #end
+
+      def log_dockerfile_image(df, image)
+        if not_empty?(df) and File.exist?(df) and not_empty?(image)
+          logfile[:dockerfile_images] = {  } if logfile[:dockerfile_images].nil?
+          d = digest_file(df)
+          logfile[:dockerfile_images][d] = [] if logfile[:dockerfile_images][d].nil?
+          logfile[:dockerfile_images][d] << image
+          write
+        end
+      end
+
+      def has_dockerfile_built_to_image?(df)
+        if not_empty?(df) 
+          if File.exist?(df) 
+            d = digest_file(df)
+          else
+            d = df
+          end
+
+          not (logfile[:dockerfile_images].nil? or logfile[:dockerfile_images][d].nil?)
+        end
+      end
+
+      def dockerfile_images(df)
+        if File.exist?(df)
+          d = digest_file(df)
+        else
+          d = df
+        end
+
+        if (logfile[:dockerfile_images].nil? or logfile[:dockerfile_images][d].nil?)
+          []
+        else
+          logfile[:dockerfile_images][d]
+        end
+      end
+
+      def has_dockerfile_seen_before?(df)
+        logger.debug "dockerfile_seen_before? #{df}"
+        if not_empty?(df) and File.exist?(df) 
+          d = Cli.digest_bin(File.read(df))
+          logger.debug "Digest : #{d}"
+          logger.debug "Record : #{logfile[:dockerfile_images]}"
+          if not logfile[:dockerfile_images].nil?
+            logfile[:dockerfile_images].include?(d)
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def digest_file(path)
+        if not_empty?(path) and File.exist?(path)
+          Cli.digest_bin(File.read(path))
+        else
+          ""
+        end
+      end
+
+      def image_has_containers?(image)
+        not logfile[image].nil? and logfile[image].length > 0
+      end
+
+      def delete_image(image, opts = {})
+        if logfile[image].nil? or is_empty?(logfile[image])
+          logfile.delete(image)
+        elsif not_empty?(opts) and opts[:force] == true
+          logfile.delete(image)
+        else
+          raise NonEmptyRecord, "Image #{image} has #{logfile[image].length} container(s). Remove image failed."
+        end
+      end
+
+      def update_last_run(image, cont)
+        if not logfile[image].nil? and not logfile[image][cont].nil?
+          logfile[image][cont][:last_run] = Time.now.to_i
+          write
+        end
+      end
+
+      def image_containers(image)
+        if not logfile[image].nil?
+          logfile[image]
+        else
+          []
+        end
+      end
+
+      def all_logs
+        logfile.freeze
+      end
+
+      private 
+      def logfile
+        if @_logfile.nil?
+          if File.exist?(log_path)
+            @_logfile = YAML.load(File.read(log_path))
+          else
+            @_logfile = {}
+          end
+        end
+        @_logfile
+      end
+
+      def write
+        File.open(log_path,"w") do |f|
+          f.write YAML.dump(logfile)
+        end
+      end
+
+      def log_path
+        if @_logPath.nil?
+          @_logPath = File.join(Dir.getwd, ".docker_run_log")
+        end
+        @_logPath
+      end
+
+      def digest
+        if @_digest.nil?
+          @_digest = Cli.digest
+        end
+        @_digest
+      end
+
+      def logger
+        if @_logger.nil?
+          @_logger = Cli.logger(:drLog)
+        end
+        @_logger
+      end
+
+    end # class DockerRunLog
+  end
+end

data/lib/docker/cli/dockerfile.rb

@@ -0,0 +1,62 @@
+
+require 'openssl'
+
+module Docker
+  module Cli
+    class Dockerfile
+
+      class NoDockerfileFound < StandardError; end
+      
+      def self.find_available(root = Dir.getwd)
+        Dir.glob("**/Dockerfile*")
+      end
+
+      def self.run_before?(dockerfile_path)
+        DockerRunLog.instance.has_dockerfile_seen_before?(dockerfile_path)
+      end
+
+      # expect dockerfile is CONTENT, not file path
+      def self.images(dockerfile)
+        DockerRunLog.instance.dockerfile_images(dockerfile)
+      end
+
+      def initialize(file)
+        @dfile = file
+      end
+
+      def render_dockerfile(vals = {}, &block)
+        if @_df.nil?
+          if @dfile.nil?
+            @_df = nil
+          else
+            if File.exist?(@dfile)
+              if is_erb_template?
+                @_df = process_dockerfile_template(@dfile, vals)
+              else
+                @_df = File.read(@dfile)
+              end
+            else
+              @_df = nil
+            end
+          end
+        end
+        @_df
+      end
+
+      def is_erb_template?
+        if File.exist?(@dfile)
+          cont = File.read(@dfile)
+          (cont =~ /<%=/ and cont =~ /%>/) != nil
+        else
+          false
+        end
+      end
+
+      def process_dockerfile_template(file, values = {})
+        raise Error, "Given dockerfile to process as template not found" if not File.exist?(file)
+        DockerfileTemplate::TemplateEngine.new.process(File.read(file), values) 
+      end
+
+    end
+  end
+end

data/lib/docker/cli/dockerfile_template/dup_gem_bundler_env.rb

@@ -0,0 +1,73 @@
+
+module Docker
+  module Cli
+    module DockerfileTemplate
+      module DupGemBundlerEnv
+      
+        # DSL entry by including into DockerfileTemplate module
+        def dup_gem_bundler_env(&block)
+          if has_dev_gems?
+            logger.debug "Detected development gems"
+
+            #add_mandatory_key(:docker_root)
+            #if not has_mandatory_keys? and block
+            #  @docker_root = block.call(:docker_root)
+            #else
+              raise TemplateKeyRequired, "docker_root is required for dup_gem_bundler_env to function" if is_empty?(@docker_root)
+            #end
+
+            # gen shell script
+            res = gen_script
+            block.call(:script_output, res) if block
+            localPath = File.join(Dir.getwd,"dup_gem_bundler_env.rb")
+            File.open(localPath,"w") do |f|
+              f.write res
+            end
+
+            inst = []
+            # copy inside docker
+            inst << "COPY #{File.basename(localPath)} /tmp/dup_gem_bundler_env.rb"
+            # run the script
+            inst << "RUN ruby /tmp/dup_gem_bundler_env.rb"
+            # for the docker just this two lines
+            # but the localPath must be there first before this two
+            # lines can come into effect
+            inst.join("\n")
+          else
+            ""
+          end
+        end
+
+        private
+        def has_dev_gems?
+          not Cli.find_dev_gems.empty? 
+        end
+
+        def gen_script
+
+          res = %Q(
+#!/usr/bin/env ruby
+
+## This file is auto-generated.
+
+<% Docker::Cli.find_dev_gems.each do |name, pa| %>
+`bundle config --global local.<%= name %> <%= File.join(@docker_root, File.basename(pa)) %>`
+<% end %>
+          )
+
+          ERB.new(res).result(binding)
+           
+        end
+
+        def logger
+          if @_logger
+            @_logger = Cli.logger(:temp_dup_gem_bundler_env)
+          end
+          @_logger
+        end
+        
+
+      end
+    end
+  end
+end

data/lib/docker/cli/dockerfile_template/match_user.rb

@@ -0,0 +1,38 @@
+
+require 'erb'
+require_relative '../user_info'
+
+module Docker
+  module Cli
+    module DockerfileTemplate
+      module MatchUser
+        
+        # DSL entry
+        def match_user
+
+          logger.debug "match_user called"
+          ui = UserInfo.user_info
+          gi = UserInfo.group_info
+
+          ERB.new(user_template).result_with_hash({ user_group_id: gi[:gid], user_group_name: gi[:group_name], user_id: ui[:uid], user_login: ui[:login] })
+           
+        end
+
+        private
+        def user_template
+          if @_ut.nil?
+            @_ut = []
+            @_ut << "RUN apt-get install -y sudo && 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"
+            @_ut << "USER <%= user_login %>"
+          end
+          @_ut.join("\n")
+        end
+
+        def logger
+          Cli.logger(:temp_match_user)
+        end
+
+      end
+    end
+  end
+end

data/lib/docker/cli/dockerfile_template.rb

@@ -0,0 +1,69 @@
+
+Dir.glob(File.join(File.dirname(__FILE__),"dockerfile_template","*.rb")).each do |f|
+  require_relative f
+end
+
+module Docker
+  module Cli
+    module DockerfileTemplate
+      class TemplateKeyRequired < StandardError; end
+      class TemplateEngine
+        include MatchUser
+        include DupGemBundlerEnv
+
+        def process(cont, values = {}, &block)
+          logger.debug "Got values : #{values}"
+          values.each do |k,v|
+
+            logger.debug "Creating field #{k}"
+            
+            self.class.class_eval <<-END
+            if not (Class.instance_methods.include?(:#{k}) and Class.instace_methods.include?(:#{k}=))
+              attr_accessor :#{k}
+            elsif not Class.instance_methods.include?(:#{k})
+              attr_reader :#{k}
+            elsif not Class.instance_methods.include?(:#{k}=)
+              attr_writer :#{k}
+            end
+            END
+
+            self.send("#{k}=", v)
+          end
+
+
+          ERB.new(cont).result(binding)
+        end
+
+        private 
+        def logger
+          if @_logger.nil?
+            @_logger = Cli.logger(:df_template)
+          end
+          @_logger
+        end
+
+        def add_mandatory_key(key)
+          if @_man.nil?
+            @_man = []
+          end
+          @_man << key if not_empty?(key)
+        end
+
+        def mandatory_keys
+          @_man
+        end
+
+        def has_mandatory_keys?
+          given = true
+          mandatory_keys.each do |mk|
+            given = Class.instance_methods.include?(mk.to_sym) and Class.instance_methods.include?("#{mk}=".to_sym)
+            break if not given
+          end
+
+          given
+        end
+
+      end
+    end
+  end
+end

data/lib/docker/cli/gem/bundler_helper.rb

@@ -0,0 +1,25 @@
+
+require 'bundler'
+
+module Docker
+  module Cli
+    module BundlerHelper
+
+      def find_local_dev_gems
+
+        res = {}
+        Bundler.load.dependencies.each do |d|
+          if not d.source.nil?
+            src = d.source
+            if src.path.to_s != "."
+              res[d.name] = src.path.expand_path.to_s
+            end
+          end
+        end
+        res
+
+      end # find_local_dev_gem
+      
+    end
+  end
+end

data/lib/docker/cli/image_helper.rb

@@ -0,0 +1,43 @@
+
+
+module Docker
+  module Cli
+    module ImageHelper
+     
+      def build_image(pmt, cmdFact)
+        
+        root = Dir.getwd
+        dockerfile = File.join(root, "Dockerfile")
+
+        again = true
+        while again
+          if not File.exist?(dockerfile)
+            dockerfile = pmt.ask(" #{dockerfile} does not exist. Please provide new location of Dockerfile: ", required: true) 
+          else
+            again = false
+          end
+        end
+
+        again = true
+        while again
+          dname = pmt.ask(" Please provide name of image at local : ", required: true)
+          if cmdFact.is_image_exist?(dname)
+            
+            reuse = pmt.yes?(" Given local image name '#{dname}' already taken. Use back the same image? 'No' to retry with new name : ")
+            if reuse 
+              again = false
+            end
+          else
+            rv = cmdFact.build_image(dname, dockerfile: dockerfile)
+            raise CommandFailed, "Build image command failed. Error was : #{rv.err_stream}"
+            again = false
+          end
+        end
+
+        dname
+
+      end
+
+    end
+  end
+end