dockerun 0.3.6 → 0.4.1

data/lib/dockerun/docker_cli.rb

@@ -0,0 +1,124 @@
+
+require 'tty/which'
+
+require_relative 'cli/command_factory'
+
+module Dockerun
+
+  # Generate docker cli string
+  class DockerCli
+    include TR::CondUtils
+
+    def self.docker_exe
+      exe = TTY::Which.which("docker")      
+      raise Error, "Docker executable cannot be found. Please make sure it is installed and in the PATH" if is_empty?(exe)
+      exe
+    end
+
+    def initialize(config, dfile)
+      @_config = config
+      @_dfile = dfile
+    end
+
+    def set_container_name(val)
+      @name = val 
+    end
+    def container_name
+      @name.nil? ? "" : @name
+    end
+    def is_container_name_given?
+      not_empty?(container_name)
+    end
+    def generated_container_name
+      if @_gen_cont_name.nil?
+        @_gen_cont_name = "#{File.basename(Dir.getwd)}_cont_name"
+      end
+      @_gen_cont_name
+    end
+
+    def keep(bool = true)
+      @keep = bool
+    end
+    def keep_container?
+      @keep.nil? ? true : @keep
+    end
+
+    def interactive(bool = true)
+      @interactive = bool
+    end
+    def is_interactive?
+      @interactive.nil? ? false : true
+    end
+
+    def mount(*mnt)
+      mnt.each do |mm|
+        mm.each do |on_host, on_docker|
+          case on_host
+          when :current_dir 
+            hostPath = Dir.getwd 
+          else
+            hostPath = File.expand_path(on_host) 
+          end
+
+          req_mounts[hostPath] = on_docker
+
+        end
+      end
+    end
+    def mounts
+      req_mounts
+    end
+
+    def port(*ports)
+      ports.each do |port|
+        raise Error, "Hash of hostPort => dockerPort is required" if not port.is_a?(Hash)
+        port.each do |hostPort, dockerPort|
+          expose_ports[hostPort] = dockerPort
+        end
+      end
+    end
+    def expose_ports
+      if @_ports.nil?
+        @_ports = {}
+      end
+      @_ports
+    end
+    def has_exposed_ports?
+      expose_ports.size > 0
+    end
+
+    def listener(&block)
+      @listener = block
+    end
+
+    def run_in_docker(cmd)
+      @cmdToBeRun = cmd
+    end
+    def command_to_be_run
+      @cmdToBeRun 
+    end
+
+    def trigger_listener(evt, *args, &block)
+      if not @listener.nil?
+        args << { docker_cli: self }
+        @listener.call(evt, *args, &block)
+      end
+    end
+
+    private
+    def method_missing(mtd, *args, &block)
+      if @_config.respond_to?(mtd)
+        @_config.send(mtd, *args, &block)
+      end
+    end
+
+    def req_mounts
+      if @_req_mounts.nil?
+        @_req_mounts = {}
+      end
+      @_req_mounts
+    end
+
+  end
+
+end

data/lib/dockerun/dsl.rb

@@ -0,0 +1,342 @@
+
+require_relative 'config'
+require_relative 'dfile'
+require_relative 'docker_cli'
+
+require_relative 'cli/command_factory'
+
+module Dockerun
+  module DSL
+    include TR::CondUtils
+
+    def set_exec_root(root)
+      @_exec_root = root
+    end
+    def exec_root
+      @_exec_root
+    end
+
+    def config(&block)
+      _config.instance_eval(&block) 
+    end
+
+    def set_dry_run_mode(bool = true, prompt = false)
+      _config.dry_run(bool, prompt)
+    end
+
+    # Main DSL for dockerfile related configurations
+    def from(base_image, &block)
+      _dfile.base_image = base_image
+      _dfile.instance_eval(&block) 
+    end
+
+    # Additional dockerfile configurations for example
+    # if user did not specify the image name, better generate 
+    # by system so that it can be traced for subsequent functions
+    # later such as delete image
+    def dockerfile_patch(&block)
+      _file.instance_eval(&block)
+    end
+
+    # Main DSL for docker cli
+    def up(&block)
+      _docker_cli.instance_eval(&block)
+    end
+
+    # Trigger point to start the ball rolling!
+    def go
+
+      # Link context with Dockerfile and docker cli
+      if not_empty?(_config.active_context)
+        self.listener do |ops, *val|
+          _config.active_context.call(ops, *val)
+        end
+
+        _dfile.listener do |ops, *val|
+          _config.active_context.call(ops, *val)
+        end
+
+        _docker_cli.listener do |ops, *val|
+          _config.active_context.call(ops, *val)
+        end
+      end
+
+      # give chance to context to verify the integrity of the
+      # workspace before proceed
+      trigger_listener(:dsl_before_go, self)
+
+      # check if image exist?
+      if not image_exist?
+        logger.debug "Image doesn't exist... proceed to build the image"
+        # if not exist, build the image giving the name
+        st, res = build_image
+        if st
+          trigger_listener(:dsl_image_built, self)
+          #puts " Image '#{image_name}' built successfully"
+        else
+          trigger_listener(:dsl_image_building_failed, self)
+          raise Error, " Image '#{image_name}' failed to be built. Error was : #{res.err_lines.join("\n")}"
+        end
+      else
+        logger.debug "Image exist... skipped image building..."
+      end
+
+      # check if container exist?
+      if container_exist?
+        trigger_listener(:dsl_before_start_container, self)
+        logger.debug "Container exist... Starting container..."
+        # container exist, start the container
+        start_container
+
+        trigger_listener(:dsl_before_attach_container, self)
+        logger.debug "Container started... attaching container..."
+        # attach to container
+        attach_container
+        trigger_listener(:dsl_after_attach_container, self)
+      else
+        trigger_listener(:dsl_before_run_container, self)
+        logger.debug "Container does not exist. Creating new container..."
+        # Container does not exist, run the container
+        run_container
+      end
+    
+    end
+
+
+    def image_name
+      if _dfile.is_image_name_given?
+        _dfile.image_name
+      else
+        _dfile.generated_image_name
+      end
+    end
+
+    def container_name
+      if _docker_cli.is_container_name_given?
+        _docker_cli.container_name
+      else
+        _docker_cli.generated_container_name
+      end
+    end
+
+
+    def listener(&block)
+      @listener = block
+    end
+
+
+    private
+    def _config
+      if @_config.nil?
+        @_config = Config.new
+      end
+      @_config
+    end
+
+    def _dfile
+      if @_dfile.nil?
+        @_dfile = Dfile.new(_config)
+      end
+      @_dfile
+    end
+
+    def _docker_cli
+      if @_docker_cli.nil?
+        @_docker_cli = DockerCli.new(_config, _dfile)
+      end
+      @_docker_cli
+    end
+
+    def docker_cf
+      if @_docker_cf.nil?
+        @_docker_cf = Dockerun::Cli::CommandFactory.new
+      end
+      @_docker_cf
+    end
+
+    def trigger_listener(evt, *args, &block)
+      if not @listener.nil?
+        @listener.call(evt, *args, &block)
+      end
+    end
+
+    # flag to bridge between script and eval mode
+    def mark_go_done
+      @_go_done = true
+    end
+    def is_go_done?
+      @_go_done.nil? ? false : @_go_done
+    end
+    # end flag
+
+    def image_exist?
+      fact = docker_cf.find_image(image_name)
+      if _config.is_dry_run?
+        dry_run_puts "Find Image : #{fact.to_s}"
+        dry_run_puts "Find Image : Returning false to allow image build"
+        false
+      else
+        res = docker_cf.find_image(image_name).run
+        res.success? and not_empty?(res.output_lines)
+      end
+    end
+
+    def build_image
+      dfile = _dfile.generate
+      dfileName = File.join(exec_root,"Dockerfile-#{SecureRandom.hex(4)}")
+      File.open(dfileName,"w") do |f|
+        f.write dfile
+      end
+
+      fact = docker_cf.build_image(image_name, dockerfile: dfileName, working_dir: exec_root)
+
+      if _config.is_gen_docker_runscript?
+        out = File.join(exec_root,"1.build-image.sh")
+        if (not File.exist?(out)) or _config.is_overwrite_docker_runscript?
+          File.open(out, "w") do |f|
+            f.puts "#!/bin/sh"
+            f.puts fact.to_s
+          end
+        end
+      end
+
+      if _config.is_dry_run?
+        dry_run_puts "Build Image : #{fact.to_s}"
+        dry_run_puts "Build Image : Returning true to proceed to next phase."
+        dry_run_puts "Generated dockerfile '#{dfileName}' shall be remained in project directory."
+        [true, nil]
+      else
+        res = fact.run(true)
+        if res.success?
+          FileUtils.rm(dFileName) if not _dfile.keep_dockerfile?
+          [true, res]
+        else
+          [false, res]
+        end
+      end
+    end
+
+
+    def container_exist?
+      if _docker_cli.keep_container?
+        fact = docker_cf.find_from_all_container(container_name)
+        if _config.is_dry_run?
+          dry_run_puts "Is container exist? : #{fact.to_s}"
+          dry_run_puts "Returning false to allow container build"
+          false
+        else
+          res = fact.run
+          res.success? and not_empty?(res.output_lines)
+        end
+      else
+        remove_container
+        false
+      end
+    end
+
+    def remove_container
+      fact = docker_cf.find_from_all_container(container_name)
+      res = fact.run
+      if res.success?
+        res.output_lines.each do |ci|
+          docker_cf.stop_container(ci).run
+          r = docker_cf.delete_container(ci).run
+          logger.debug "Delete container : #{r.success?} / #{r.success? ? r.output_lines.join("\n") : r.err_lines.join("\n")}"
+        end
+      else
+        logger.debug "Failed to find all container by name '#{container_name}'"
+      end
+    end
+
+    def start_container
+      fact = docker_cf.find_running_container(container_name)
+      fact2 = docker_cf.start_container(container_name)
+
+      if _config.is_gen_docker_runscript?
+        out = File.join(exec_root,"3.start-container.sh")
+        if (not File.exist?(out)) or _config.is_overwrite_docker_runscript?
+          File.open(out, "w") do |f|
+            f.puts "#!/bin/sh"
+            f.puts fact.to_s
+          end
+        end
+      end
+
+      if _config.is_dry_run?
+        dry_run_puts "Find running container : #{fact.to_s}"
+        dry_run_puts "Start container : #{fact2.to_s}"
+        [true, nil]
+      else
+        res = fact.run
+        if res.success? and not_empty?(res.output_lines)
+          # already running so ignore
+          [true, res]
+        else
+          res2 = fact2.run
+          [res2.success?, res2]
+        end
+      end
+    end
+
+    def attach_container
+      fact = docker_cf.attach_container(container_name)
+
+      if _config.is_gen_docker_runscript?
+        out = File.join(exec_root,"4.attach-container.sh")
+        if (not File.exist?(out)) or _config.is_overwrite_docker_runscript?
+          File.open(out, "w") do |f|
+            f.puts "#!/bin/sh"
+            f.puts fact.to_s
+          end
+        end
+      end
+      
+      if _config.is_dry_run?
+        dry_run_puts "Attach container : #{fact.to_s}"
+      else
+        fact.run 
+      end
+
+    end
+
+    def run_container
+
+      params = { interactive: _docker_cli.is_interactive?, tty: _docker_cli.is_interactive?, del: !_docker_cli.keep_container?, container_name: container_name, match_user: _config.set_current_user?, command: _docker_cli.command_to_be_run, mounts: _docker_cli.mounts }
+
+      params[:ports] = {} if params[:ports].nil?
+      params[:ports].merge!(_docker_cli.expose_ports) if _docker_cli.has_exposed_ports? 
+
+      rparams = _docker_cli.trigger_listener(:docker_cli_construct_command, params)
+      rparams = params if is_empty?(rparams)
+
+      fact = docker_cf.create_container_from_image(image_name, rparams)
+
+      if _config.is_gen_docker_runscript?
+        out = File.join(exec_root,"2.create-container.sh")
+        if (not File.exist?(out)) or _config.is_overwrite_docker_runscript?
+          File.open(out, "w") do |f|
+            f.puts "#!/bin/sh"
+            f.puts fact.to_s
+          end
+        end
+      end
+
+      if _config.is_dry_run?
+        dry_run_puts "Run container : #{fact.to_s}"
+      else
+        fact.run 
+      end
+    end
+    
+
+    def dry_run_puts(msg)
+      puts "[DryRun] #{msg}" if _config.is_dry_run_prompt?
+    end
+
+
+    def logger
+      Dockerun.logger(:dockerun_dsl)
+    end
+
+  end
+end

data/lib/dockerun/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dockerun
-  VERSION = "0.3.6"
+  VERSION = "0.4.1"
 end

data/lib/dockerun.rb

@@ -3,41 +3,49 @@
 require 'toolrack'
 require 'teLogger'
 
-require 'colorize'
-require 'tty/prompt'
+require 'tty/command'
+require 'tty/which'
 
 require_relative "dockerun/version"
+require_relative 'dockerun/dsl'
 
-require_relative 'dockerun/command/dockerun'
-require_relative 'dockerun/command/init'
-require_relative 'dockerun/command/run'
-require_relative 'dockerun/command/reset_image'
-require_relative 'dockerun/command/run_new_container'
-require_relative 'dockerun/command/remove_container'
-require_relative 'dockerun/command/run_new_image'
-require_relative 'dockerun/command/stop_container'
-
-require_relative 'dockerun/template/template_writer'
-require_relative 'dockerun/template/template_engine'
+require_relative 'dockerun/cli_engine'
 
 module Dockerun
+  include TR::CondUtils
+
   class Error < StandardError; end
+  class InsufficientParameter < StandardError; end
   # Your code goes here...
 
-  def self.udebug(msg)
-    logger.tdebug(:dockerun, msg) if is_user_debug_on?
-  end
-
-  def self.logger
+  def self.logger(tag = nil, &block)
     if @_logger.nil?
-      @_logger = TeLogger::Tlogger.new
+      drLogout = ENV["DR_LOGOUT"]
+      if is_empty?(drLogout)
+        @_logger = TeLogger::Tlogger.new('dockerun.log',5, 5*1024*1024)
+      else
+        @_logger = TeLogger::Tlogger.new(drLogout, 5, 5*1024*1024)
+      end
     end
-    @_logger
-  end
 
-  def self.is_user_debug_on?
-    val = ENV["DOCKERUN_DEBUG"]
-    (not val.nil? and val == "true")
+    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 = :dockerun
+        @_logger
+      else
+        # no block but tag is given? hmm
+        @_logger.tag = tag
+        @_logger
+      end
+    end
   end
 
+
+
 end

data/sig/dockerun.rbs

@@ -0,0 +1,4 @@
+module Dockerun
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end