Hitcher 0.1.0

data/lib/hitcher/global.rb

@@ -0,0 +1,24 @@
+
+require 'singleton'
+require 'tlogger'
+
+require_relative 'config'
+
+module Hitcher
+  class Global
+    include Singleton
+
+    attr_accessor :glog, :config
+    def initialize
+      @glog = Tlogger.init
+      @glog.show_source
+      @glog.tag = "Hitcher"
+
+      @config = Config.init_config if @config.nil?
+    end
+
+    def reload_config
+      @config = Config.init_config
+    end
+  end
+end

data/lib/hitcher/providers/docker/command_builder.rb

@@ -0,0 +1,206 @@
+
+require_relative '../../global'
+require 'toolrack'
+
+require 'ptools'
+
+module Hitcher
+  module Docker
+    module CommandBuilder
+      include Antrapol::ToolRack::ConditionUtils
+
+      def docker_exe
+        path = File.which("docker")
+        if path.nil?
+          "docker"
+        else
+          path
+        end
+      end
+
+      def cb_find_image(name, tag = "", opts = { })
+        raise Hitcher::Error, "Name is mandatory" if is_empty?(name)     
+        cmd = []
+        cmd << docker_exe
+        cmd << "images"
+        cmd << "-q"
+        if not_empty?(tag)
+          cmd << "#{name}:#{tag}"
+        else
+          cmd << name
+        end
+
+        ccmd = cmd.join(" ")
+        logger.debug "Find image: #{ccmd}"
+        ccmd
+      end
+
+      def cb_find_running_container(name, opts = { })
+        raise Hitcher::Error, "Name is mandatory" if is_empty?(name)     
+        cmd = []
+        cmd << docker_exe
+        cmd << "ps"
+        cmd << "-q"
+        cmd << "-f"
+        cmd << "name=#{name}"
+
+        ccmd = cmd.join(" ")
+        logger.debug "Find container: #{ccmd}"
+        ccmd
+       
+      end
+
+      def cb_find_all_container(name, opts = { })
+        raise Hitcher::Error, "Name is mandatory" if is_empty?(name)     
+        cmd = []
+        cmd << docker_exe
+        cmd << "ps"
+        cmd << "-aq"
+        cmd << "-f"
+        cmd << "name=#{name}"
+
+        ccmd = cmd.join(" ")
+        logger.debug "Find all container: #{ccmd}"
+        ccmd
+        
+      end
+
+      def cb_build_image(name = "", opts = {  })
+        cmd = []
+        cmd << docker_exe
+        cmd << "build"
+        if not (name.nil? or name.empty?)
+          cmd << "-t #{name}"
+        end
+        cmd << "."
+
+        ccmd = cmd.join(" ")
+        Hitcher::Global.instance.glog.debug "Build Image : #{ccmd}"
+
+        ccmd
+      end # build_image
+
+      def cb_create_container_from_image(image, opts = { interactive: true })
+        cmd = []
+        cmd << docker_exe
+        cmd << "run"
+        cmd << "-i" if opts[:interactive] == true
+        cmd << "-t" if opts[:tty] == true
+        if not (opts[:container_name].nil? or opts[:container_name].empty?)
+          cname = opts[:container_name]
+          cmd << "--name #{cname}"
+        end
+
+        cmd << process_mount(opts)
+        cmd << process_port(opts)
+
+        cmd << image
+
+        if not_empty?(opts[:command])
+          cmd << "\"#{opts[:command]}\""
+        end
+        
+        ccmd = cmd.join(" ")
+        Hitcher::Global.instance.glog.debug "Run Container from Image : #{ccmd}"
+
+        ccmd
+      end # run_container_from_image
+
+      def cb_start_container(container, opts = { })
+
+        cmd = []
+        cmd << docker_exe
+        cmd << "container"
+        cmd << "start"
+        cmd << container
+
+        ccmd = cmd.join(" ")
+
+        Hitcher::Global.instance.glog.debug "Start Container : #{ccmd}"
+
+        ccmd
+      end
+
+      def cb_run_command_in_container(container, opts = {  })
+        cmd = []
+        cmd << docker_exe
+        cmd << "container"
+        cmd << "exec"
+
+        if is_empty?(opts[:command])
+          cmd << "-t" if not_empty?(opts[:tty]) and opts[:tty] == true
+          cmd << "-i" if not_empty?(opts[:interactive]) and opts[:interactive] == true
+        end
+
+        cmd << container
+
+        if is_empty?(opts[:command])
+          cmd << "/bin/bash --login"
+        else
+          cmd << opts[:command]
+        end
+
+        ccmd = cmd.join(" ")
+        Hitcher::Global.instance.glog.debug "Run command in container : #{ccmd}"
+
+        ccmd
+      end # container_prompt
+
+
+      private
+      def logger
+        if @logger.nil?
+          @logger = Hitcher::Global.instance.glog
+        end
+        @logger
+      end
+
+      def process_mount(opts)
+        if not (opts[:mounts].nil? or opts[:mounts].empty?)
+          m = opts[:mounts]
+          m = [m] if not m.is_a?(Array)
+          res = []
+          m.each do |mm|
+            l = []
+            l << "-v "
+            l << mm[:host]
+            l << ":"
+            l << mm[:docker]
+            res << l.join
+          end
+
+          res.join(" ")
+        else
+          ""
+        end
+        
+      end # process_mount
+
+      def process_port(opts)
+         if not (opts[:ports].nil? or opts[:ports].empty?)
+          po = opts[:ports]
+          po = [po] if not po.is_a?(Array)
+          res = []
+          po.each do |ppo|
+            l = []
+            l << "-p "
+            l << ppo[:host]
+            l << ":"
+            l << ppo[:docker]
+            res << l.join
+          end
+
+          res.join(" ")
+        else
+          ""
+        end
+        
+      end
+
+    end
+
+    class DockerCommandBuilder
+      include Hitcher::Docker::CommandBuilder
+    end
+  end
+end

data/lib/hitcher/providers/docker/command_runner.rb

@@ -0,0 +1,156 @@
+
+require "tty-prompt"
+require 'tty-command'
+require 'toolrack'
+require_relative "command_builder"
+require_relative "../../command_runner"
+
+module Hitcher
+  module Docker
+    module CommandRunner
+      include Antrapol::ToolRack::ConditionUtils
+      include Hitcher::Docker::CommandBuilder
+      include Hitcher::CommandRunner
+
+      def initialize(docker)
+        @dockerConf = docker
+      end
+
+      def image_exist?(opts = { })
+        name = opts[:image_name] || @dockerConf.image
+        tag = opts[:image_tag] || ""
+
+        cmd = cb_find_image(name, tag)
+        run_command(cmd)
+      end
+
+      def container_exist?(opts = { })
+
+        name = opts[:container_name] || @dockerConf.cName
+
+        if opts[:new_instance]
+          name = "#{name}_#{Time.now.localtime.strftime("%Y%m%d_%H%M%S_%L%N")}"
+          opts[:new_container_name] = name
+        end
+
+        cmd = cb_find_running_container(name, opts)
+
+        res, out, err = run_command(cmd)
+        if is_empty?(out)
+          cmd2 = cb_find_all_container(name, opts)
+          res2, out2, err2 = run_command(cmd2)
+          if is_empty?(out2)
+            [false, ""]
+          else
+            [true, :stopped, out2]
+          end
+        else
+          [true,:running, out]
+        end
+      end
+
+      # build new image based on Dockerfile
+      def build_image(opts = { })
+
+        df = File.join(Dir.getwd, "Dockerfile")
+        if not @dockerConf.df.is_empty?
+          File.open(df,"w") do |f|
+            f.write @dockerConf.df.cont.join("\n")
+          end
+        elsif not File.exist?(df) 
+          raise Exception, "No Dockerfile available to build image."
+        end
+
+        name = opts[:image_name] || @dockerConf.image
+        cmd = cb_build_image(name, opts)
+        run_command(cmd)
+      end # build_image
+
+      def create_container(opts = { })
+        cName = opts[:container_name] || @dockerConf.cName
+        iName = opts[:image_name] || @dockerConf.image
+
+        opt = { }
+        opt.merge!(opts)
+        if opts[:new_instance]
+          opt[:container_name] = opts[:new_container_name]
+        else
+          opt[:container_name] = cName
+        end
+        opt[:mounts] = @dockerConf.mounts.collect { |m| m.hashify }
+        opt[:ports] = @dockerConf.exposes.collect { |e| e.hashify }
+        cmd = cb_create_container_from_image(iName, opt)
+        begin
+          v = run_in_new_terminal(cmd)
+          [:term,v]
+        rescue TerminalNotDefined => ex
+          logger.debug "Terminal is not set. Creating the shell script instead"
+          path = File.join(Dir.getwd,"create_container.sh")
+          File.open(path,"w") do |f|
+            f.puts "#!/bin/sh"
+            f.puts ""
+            f.puts cmd
+            f.puts
+          end
+
+          FileUtils.chmod "+x", path
+
+          [:file, path]
+        end
+      end
+
+      def start_container(opts = { })
+        name = opts[:name] || @dockerConf.cName
+        if opts[:new_instance]
+          name = opts[:new_container_name]
+        end
+
+        cmd = cb_start_container(name, opts)
+        run_command(cmd)
+      end
+
+      def run_command_in_container(command = "", opts = { })
+
+        name = opts[:container_name] || @dockerConf.cName
+        if opts[:new_instance]
+          name = opts[:new_container_name]
+        end
+        opt = { }
+        opt.merge!(opts)
+        opt[:command] = command
+        cmd = cb_run_command_in_container(name, opt)
+
+        # if command is empty default is "/bin/bash --login"
+        if is_empty?(command) or opts[:tty] == true or opts[:interactive] == true
+          begin
+            v = run_in_new_terminal(cmd)
+            [:term, v]
+          rescue TerminalNotDefined => ex
+
+            path = File.join(Dir.getwd,"prompt.sh")
+            logger.debug "Terminal is not set. Creating the shell script for run command in container instead [#{File.basename(path)}]"
+            File.open(path,"w") do |f|
+              f.puts "#!/bin/sh"
+              f.puts ""
+              f.puts cmd
+              f.puts
+            end
+
+            FileUtils.chmod "+x", path
+
+            [:file, path]
+
+          end
+        else
+          run_command(cmd)
+        end
+
+      end
+
+    end # module CommandRunner
+
+    class DockerCommandExecutor
+      include Hitcher::Docker::CommandRunner
+    end
+  end
+end

data/lib/hitcher/providers/docker/dsl.rb

@@ -0,0 +1,229 @@
+
+require_relative 'template'
+require_relative 'command_builder'
+require_relative 'command_runner'
+
+module Hitcher
+  module Docker
+
+    class Mount
+      attr_accessor :host, :docker
+      def initialize(host = "",docker = "")
+        @host = host
+        @docker = docker
+      end
+
+      def hashify
+        { host: @host, docker: @docker }
+      end
+
+      def self.parse(blc)
+        res = []
+        if not (blc.nil? or blc.empty?)
+          blc.each do |e|
+            if e =~ /mount/
+              l = e.split(" ")
+              if l.length == 2
+              else
+              end
+            elsif e =~ /,/
+              # handle host: /home/xxx/dev, docker: /opt/dev
+              m = Mount.new
+              e.split(",").each do |ee|
+                s = ee.split(":")
+                case s[0].strip
+                when "host"
+                  m.host = translate(s[1].strip)
+                when "docker"
+                  m.docker = s[1].strip
+                else
+                  raise Hitcher::Error, "Unknown mount point key '#{s[0]}'"
+                end
+              end
+
+              res << m
+            elsif e =~ /:/
+              # handle host:docker ==> /home/xxx/dev:/opt/dev
+              ee = e.split(":")
+              m = Mount.new
+              m.host = translate(ee[0])
+              m.docker = ee[1]
+              res << m
+            end
+          end
+        end
+
+        res
+      end # parse
+
+      def self.translate(key)
+        case key.upcase
+        when "$PWD","."
+          Dir.getwd
+        else
+          if key =~ /../
+            File.expand_path(key)
+          else
+            key
+          end
+        end
+      end
+    end # class Mount
+
+    class Port
+      attr_accessor :host, :docker
+      def initialize(host = nil, docker = nil)
+        @host = host
+        @docker = docker
+      end
+
+      def hashify
+        { host: @host, docker: @docker }
+      end
+    end # class Port
+
+    # 
+    # class Dockerfile
+    #
+    class Dockerfile
+      attr_reader :cont
+      def parse(blc)
+        @cont = []
+        if not (blc.nil? or blc.empty?)
+          blc.each do |e|
+            if e =~ /dockerfile/
+              l = e.split(" ")
+              if l.length == 2
+                # no parameters
+              else
+                # todo extract parameters
+              end
+
+            elsif e.strip != "end"
+              @cont << e
+            end
+          end
+        end
+      end
+
+      def is_empty?
+        @cont.nil? or @cont.empty?
+      end
+    end # class Dockerfile
+
+    ## 
+    ## Module Dsl
+    ##
+    module Dsl
+     
+      attr_reader :image, :cName, :df, :mounts, :exposes, :interactive_mode, :tty_mode
+
+      def image_name(name)
+        @image = name
+      end
+
+      def container_name(name)
+        @cName = name
+      end
+
+      def block_kw?(kw)
+        ["dockerfile","mount"].include?(kw.to_s)
+      end
+
+      def handle_block(kw,blc)
+        send(kw,blc)
+      end
+
+      def dockerfile(blc)
+        @df = Dockerfile.new
+        @df.parse(blc)
+      end
+
+      def mount(blc)
+        @mounts = Mount.parse(blc)
+      end
+
+      def interactive(val)
+        @interactive_mode = val
+      end
+
+      def tty(val)
+        @tty_mode = val
+      end
+
+      def expose(port)
+        if not port.nil? 
+          @exposes = [] if @exposes.nil?
+          po = Port.new
+          if port.to_s =~ /:/
+            ppo = port.to_s.split(":")
+            po.host = ppo[0]
+            po.docker = ppo[1]
+          else
+            # only single value is given 
+            po.docker = port
+            po.host = port
+          end
+          @exposes << po
+        end
+      end # expose
+
+      ## 
+      ## End of DSL
+      ##
+
+      def command
+        if @builder.nil?
+          @builder = DockerCommandBuilder.new
+        end
+        @builder
+      end
+
+      def command_executor
+        if @exec.nil?
+          @exec = DockerCommandExecutor.new(self)
+        end
+        @exec
+      end
+
+      # 
+      # Operation
+      #
+      def gen
+        @logger.debug "Generate output files!"
+        
+        te = Hitcher::Docker::TemplateEngine.new
+
+        if not @dockerfile.nil?
+          te.build_template(:dockerfile, { image: @image, dockerfile: @df.cont  })
+          @logger.debug "Dockerfile generated"
+        end
+
+        te.build_template(:build_container, { image_name: @image })
+
+        # run script
+        mm = @mounts.collect { |m| m.hashify }
+        pp = @exposes.collect { |po| po.hashify }
+        te.build_template(:run_container, { mounts: mm, ports: pp, container_name: @cName, interactive: true, image: @image  })
+        @logger.debug "run_container generated"
+
+        te.build_template(:start_container, { container_name: @cName, drop_to_prompt: true })
+
+        te.build_template(:container_prompt, { container_name: @cName })
+
+      end # generate output files
+
+    end # module Dsl
+
+    # initialize dynamically by
+    # DSL method container()
+    class DockerDsl
+      include Hitcher::Docker::Dsl
+
+      def initialize(opts = { logger: Hitcher::Global.instance.glog })
+        @logger = opts[:logger] || Hitcher::Global.instance.glog
+      end
+
+    end # class DockerDsl
+  end
+end