docker-cli 0.3.1 → 0.5.0

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

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