dockerun 0.3.6 → 0.4.1

data/lib/dockerun/cli_engine.rb

@@ -0,0 +1,122 @@
+
+require 'tty/prompt'
+require_relative 'cli/run'
+require_relative 'cli/delete_container'
+require_relative 'cli/delete_image'
+
+module Dockerun
+  class CliEngine
+    include TR::ArgUtils
+
+    arg_spec do
+      opt "i", "Initialize sample dockerspec at given directory as next argument" do |v|
+        init(v)
+      end
+      opt_alias "i", "init"
+
+      opt "r", "Run the dockerspec at given directory as next argument" do |v|
+        run(v)
+      end
+      opt_alias "r","run"
+
+      opt "dc", "Delete container at given directory as next argument" do |v|
+        delete_container(v)
+      end
+
+      opt "di", "Delete image and its associated container(s) at given directory as next argument" do |v|
+        delete_image(v)
+      end
+
+      opt 'clean', "Clean generated Dockerfile and temporary files at given directory as next argument" do |v|
+        clean_env(v)
+      end
+
+      opt 'help', "Command help" do
+        print_help
+      end
+
+    end
+
+    def print_help
+      pmt = self.class.pmt
+      pmt.puts ""
+      pmt.puts " Dockerun version #{Dockerun::VERSION}".magenta
+      pmt.puts ""
+      pmt.puts " Supported options : "
+      self.class.arg_options.each do |key, val|
+        pmt.puts " #{key}\t\t#{val[:desc]}"
+      end
+      pmt.puts ""
+    end
+
+    def self.select_spec(root)
+      raise InsufficientParameter, "Given path cannot be empty or nil" if is_empty?(root)
+
+      #sel = Dir.entries(Dir.getwd).sort
+      sel = Dir.entries(root).sort
+      default = sel.select { |e| (e =~ /^dockerspec/) != nil }
+      selSpec = pmt.select(" Please select the dockerspec to proceed : ", filter: true, default: default.first) do |m|
+        sel.each do |s|
+          next if sel == "." or sel == ".." or File.directory?(s)
+          m.choice s, File.expand_path(s)
+        end
+      end
+
+      selSpec
+    end
+
+
+    def init(root)
+      raise InsufficientParameter, "Given path cannot be empty or nil" if is_empty?(root)
+
+      root = File.expand_path(root)
+      template = File.join(File.dirname(__FILE__),"..","..","dockerspec.sample")        
+      if File.exist?(template)
+        #FileUtils.cp template, File.join(Dir.getwd, "dockerspec.sample")
+        FileUtils.cp template, File.join(root, "dockerspec.sample")
+      end
+    end
+
+    def run(root)
+      raise InsufficientParameter, "Given path cannot be empty or nil" if is_empty?(root)
+
+      root = File.expand_path(root)
+      r = Dockerun::Cli::Run.new
+      r.start(root)
+    end
+
+    def delete_container(root)
+      raise InsufficientParameter, "Given path cannot be empty or nil" if is_empty?(root)
+      root = File.expand_path(root)
+      d = Dockerun::Cli::DeleteContainer.new
+      d.start(root)
+    end
+
+    def delete_image(root)
+      raise InsufficientParameter, "Given path cannot be empty or nil" if is_empty?(root)
+      root = File.expand_path(root)
+      d = Dockerun::Cli::DeleteImage.new
+      d.start(root)
+    end
+
+    def clean_env(root)
+      raise InsufficientParameter, "Given path cannot be empty or nil" if is_empty?(root)
+      root = File.expand_path(root)
+
+      Dir.glob(File.join(root,"Dockerfile-*")).each do |f|
+        FileUtils.rm(f)
+      end
+      pa = File.join(root,"script_for_gem.sh")
+      FileUtils.rm(pa) if File.exist?(pa)
+      self.class.pmt.puts " Generated Dockerfile-* and script_for_gem.sh is deleted at '#{root}'".green
+    end
+
+    def self.pmt
+      if @_pmt.nil?
+        @_pmt = TTY::Prompt.new
+      end
+      @_pmt
+    end
+
+  end
+end

data/lib/dockerun/config.rb

@@ -1,115 +1,80 @@
 
-require 'yaml'
+require_relative 'context/rubygems'
 
 module Dockerun
   class Config
     include TR::CondUtils
 
-    FILENAME = ".dockerun".freeze
-
-    def self.from_storage
-      path = File.join(Dir.getwd, FILENAME)
-      if File.exist?(path)
-        #cont = nil
-        #File.open(path,"r") do |f|
-        #  cont = f.read
-        #end
-
-        #Config.new(YAML.load(cont), true)
-        Config.new(YAML.unsafe_load_file(path), true)
-      else
-        Config.new({}, false)
-      end
+    def set_workdir(path)
+      @workdir = path 
     end
-
-    def self.remove
-      path = File.join(Dir.getwd, FILENAME)
-      FileUtils.rm(path) if File.exist?(path)
-    end
-
-    def initialize(configHash = {  }, configFileAvail = false)
-      @config = configHash 
-      @images = @config[:images] || {  }
-      @confFileAvail = configFileAvail
-      #@images = {  } if @images.nil?
+    def workdir
+      if @workdir.nil?
+        @workdir = File.join("/opt",File.basename(Dir.getwd))
+      end
+      @workdir
     end
-
-    def isConfigFileAvail?
-      @confFileAvail
+    def is_workdir_given?
+      not_empty?(@workdir)
     end
 
-    def image_names
-      @images.keys
-    end
 
-    def add_image(name)
-      @images[name] = {  } if not_empty?(name) and not @images.keys.include?(name)
+    def set_platform(val)
+      @platform = val
     end
-
-    def remove_image(name)
-      @images.delete(name)
+    def platform
+      if is_empty?(@platform)
+        # wild guess
+        @platform = :debian
+      end
+      @platform
     end
 
-    def container_names(imageName)
-      @images[imageName].keys
-    end
 
-    def container_configs(imageName, name)
-      @images[imageName].nil? ? {} : @images[imageName][name].nil? ? {} : @images[imageName][name]
+    def set_current_user(bool = true)
+      @set_current_user = bool
     end
-
-    def add_container(imageName, name)
-      @images[imageName] = {  } if @images[imageName].nil?
-      @images[imageName][name] = {} if @images[imageName][name].nil?
+    def set_current_user?
+      @set_current_user.nil? ? true : @set_current_user
     end
 
-    def remove_container(imageName, name)
-      if not @images[imageName].nil?
-        @images[imageName].delete(name) 
-      end
-    end
 
-    def add_mount_to_container(imageName, container, mount)
-      add_container(imageName, container)
-      @images[imageName][container][:mount] = [] if @images[imageName][container][:mount].nil?
-      case mount.class
-      when Array
-        @images[imageName][container][:mount]concat(mount)
+    def activate_context(ctx, &block)
+      case ctx
+      when :rubygems
+        @active_context = Context::Rubygems.new(self)
       else
-        @images[imageName][container][:mount] << mount
+        raise Error, "Unknown context '#{ctx}'"
       end
+      @active_context.instance_eval(&block)
     end
-
-    def container_mount_points(imageName, container)
-      res = @images[imageName][container]
-      if is_empty?(res) or is_empty?(res[:mount])
-        []
-      else
-        res[:mount]
-      end
+    def active_context
+      @active_context
     end
 
-    def add_port_mapping_to_container(imageName, container, port_mapping)
-      add_container(imageName, container)
-      @images[imageName][container][:port_mapping] = [] if @images[imageName][container][:port_mapping].nil?
-      case mount.class
-      when Array
-        @images[imageName][container][:port_mapping]concat(port_mapping)
-      else
-        @images[imageName][container][:port_mapping] << port_mapping
-      end
+ 
+    def gen_docker_runscript(bool = true, overwrite = false)
+      @_gen_docker_runscript = bool 
+      @_overwrite_docker_runscript = overwrite
     end
+    def is_gen_docker_runscript?
+      @_gen_docker_runscript.nil? ? false : @_gen_docker_runscript
+    end
+    def is_overwrite_docker_runscript?
+      @_overwrite_docker_runscript.nil? ? false : @_overwrite_docker_runscript
+    end
+   
 
-
-    def to_storage
-      res = { images: @images } 
-
-      path = File.join(Dir.getwd, FILENAME)
-      File.open(path,"w") do |f|
-        f.write YAML.dump(res)
-      end
+    def dry_run(bool = true, prompt = true)
+      @dry_run = bool 
+      @dry_run_prompt = prompt
+    end
+    def is_dry_run?
+      @dry_run.nil? ? false : @dry_run
+    end
+    def is_dry_run_prompt?
+      @dry_run_prompt.nil? ? false : @dry_run_prompt
     end
-    alias_method :save, :to_storage
 
   end
 end

data/lib/dockerun/context/rubygems.rb

@@ -0,0 +1,142 @@
+
+require 'bundler'
+
+require_relative '../cli/command_factory'
+
+module Dockerun
+  module Context
+
+    class Rubygems
+      include TR::CondUtils
+
+      def self.is_rubygems?(path)
+        fs = Dir.entries(path)
+        gs = fs.select { |s| s =~ /.gemspec/ }
+        fs.include?("Gemfile") and fs.include?("Gemfile.lock") and not_empty?(gs)
+      end
+
+      def initialize(conf)
+        @_config = conf
+      end
+
+      def call(ops, *val)
+        case ops
+        when :dsl_before_go
+          check_integrity 
+
+        when :dsl_image_built
+          FileUtils.rm(gen_file_name) if not is_keep_gen_file?
+
+        when :dockerfile_before_workdir
+          init_script_in_dockerfile
+
+        when :docker_cli_construct_command
+          para = val.first
+          if not_empty?(dev_gems_mounts)
+            para[:mounts] = {} if para[:mounts].nil?
+            para[:mounts].merge!(dev_gems_mounts)
+          end
+          para
+
+        end
+      end
+
+      def check_integrity
+        puts `cd #{Dir.getwd} && bundle`
+      end
+
+      def keep_gen_file(bool = true)
+        @_keep_gen_file = bool
+      end
+      def is_keep_gen_file?
+        @_keep_gen_file.nil? ? true : @_keep_gen_file
+      end
+
+      def gen_file_name
+        "script_for_gem.sh"
+      end
+
+      # shell script to set the env
+      def init_script_in_dockerfile
+        cmd = ["#!/usr/bin/env ruby"]
+        if is_duplicate_dev_env?
+          if has_dev_gems?
+            find_local_dev_gems.each do |name, path|
+              if @_config.is_workdir_given?
+                root = File.dirname(@_config.workdir)
+              else
+                root = "/opt"
+              end
+
+              dockerPath = File.join(root, name)
+              cmd << "`bundle config --global local.#{name} #{dockerPath}`"
+              dev_gems_mounts[path] = dockerPath
+            end
+          end
+        end
+
+        cmd << "`echo 'alias be=\"bundle exec\"' >> ~/.bashrc`"
+
+        initScript = cmd.join("\n")
+        File.open(gen_file_name,"w") do |f|
+          f.write initScript
+        end
+        `chmod +x script_for_gem.sh`
+
+        cont = []
+        cont << "COPY script_for_gem.sh /tmp"
+        cont << "RUN /tmp/script_for_gem.sh"
+        cont.join("\n")
+      end
+
+      def duplicate_dev_env(bool = true)
+        @dup_dev_env = bool
+      end
+      def is_duplicate_dev_env?
+        @dup_dev_env.nil? ? true : @dup_dev_env
+      end
+
+
+      def dev_gems_mounts
+        if @_dev_gems_mounts.nil?
+          @_dev_gems_mounts = {}
+        end
+        @_dev_gems_mounts
+      end
+
+
+      def has_dev_gems?
+        not find_local_dev_gems.empty?        
+      end
+
+      def find_local_dev_gems
+
+        if @_dev_gems.nil?
+
+          @_dev_gems = {}
+          Bundler.load.dependencies.each do |d|
+            if not d.source.nil?
+              src = d.source
+              if src.path.to_s != "."
+                @_dev_gems[d.name] = src.path.expand_path.to_s
+              end
+            end
+          end
+
+        end
+
+        @_dev_gems
+
+      end # find_local_dev_gem
+
+      def docker_cli
+        if @_docker_cli.nil?
+          @_docker_cli = Dockerun::Cli::CommandFactory.new
+        end
+        @_docker_cli
+      end
+
+    end # class RubygemsEngine
+
+  end
+end

data/lib/dockerun/dfile.rb

@@ -0,0 +1,204 @@
+
+require_relative 'cli/user_info'
+
+module Dockerun
+
+  # Generate Dockerfile
+  class Dfile
+    include TR::CondUtils
+
+    def initialize(config)
+      @_config = config
+    end
+
+    # DSL
+    def set_image_name(val)
+      @image_name = val
+    end
+    def image_name
+      @image_name
+    end
+    def is_image_name_given?
+      not_empty?(@image_name)
+    end
+    def generated_image_name
+      if @_genImgName.nil?
+        @_genImgName = "#{File.basename(Dir.getwd.gsub(" ","-"))}_docker_image"
+      end
+      @_genImgName
+    end
+
+    # DSL
+    def output=(val)
+      @output = val
+    end
+    def output_filename
+      @output
+    end
+
+    def install(*app)
+      @installApp = app
+    end
+    def required_app
+      @installApp.nil? ? [] : @installApp
+    end
+
+    def set_command(*val)
+      @cmd = val 
+    end
+    def command
+      @cmd
+    end
+    def default_command
+      ["/bin/bash"]
+    end
+    def is_command_given?
+      not_empty?(command)
+    end
+
+    def base_image=(img)
+      @base_image = img
+    end
+    def base_image
+      @base_image
+    end
+
+    def set_workdir(bool = true)
+      @set_workdir = bool
+    end
+    def is_set_workdir?
+      @set_workdir.nil? ? true : @set_workdir
+    end
+
+    def skip_update(bool = false)
+      @skip_update = bool
+    end
+    def skip_update?
+      @skip_update.nil? ? false : @skip_update
+    end
+
+    def skip_upgrade(bool = false)
+      @skip_upgrade = bool 
+    end
+    def skip_upgrade?
+      @skip_upgrade.nil? ? false : @skip_upgrade
+    end
+
+    def keep_dockerfile(bool = true)
+      @keep_dockerfile = bool
+    end
+    def keep_dockerfile?
+      @keep_dockerfile.nil? ? true : @keep_dockerfile
+    end
+
+
+    # for context to install listener
+    def listener(&block)
+      @listener = block
+    end
+
+    def generate(opts = {})
+      
+      opts = {} if opts.nil?
+
+      config = @_config
+      raise Error, "Config is required" if config.nil?
+
+      cont = []
+      cont << "FROM #{base_image}"
+      cont << ""
+
+      pkgMgr = pkg_mgr(config)
+
+      if not skip_update? or not skip_upgrade?
+        st = []
+        st << "#{pkgMgr} update" if not skip_update?
+        st << "#{pkgMgr} -y upgrade" if not skip_upgrade?
+        cont << "RUN #{st.join(" && ")}" if not_empty?(st)
+        cont << ""
+      end
+
+      cb = trigger_listener(:dockerfile_before_install_app)
+      cont << cb if not_empty?(cb)
+      cont << "RUN #{pkgMgr} -y install #{required_app.join(" ")}"
+      cont << ""
+
+      cb = trigger_listener(:dockerfile_after_install_app)
+      cont << cb if not_empty?(cb)
+
+      if config.set_current_user?
+        #RUN 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
+        #USER <%= @user_login %>
+
+        uInfo = Dockerun::Cli::UserInfo.user_info
+        gInfo = Dockerun::Cli::UserInfo.group_info
+
+        uCmd = []
+        uCmd << "groupadd -f -g"
+        uCmd << gInfo[:gid]
+        uCmd << gInfo[:group_name]
+        uCmd << "&& useradd"
+        uCmd << "-u"
+        uCmd << uInfo[:uid]
+        uCmd << "-g"
+        uCmd << gInfo[:gid]
+        uCmd << "-m"
+        uCmd << uInfo[:login]
+        uCmd << "&& usermod -aG sudo"
+        uCmd << uInfo[:login]
+        uCmd << "&& echo '#{uInfo[:login]} ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers"
+
+        cb = trigger_listener(:dockerfile_before_add_user)
+        cont << cb if not_empty?(cb)
+
+        cont << "RUN #{pkgMgr} -y install sudo && #{uCmd.join(" ")}"
+        cont << "USER #{uInfo[:login]}"
+        cont << ""
+
+        cb = trigger_listener(:dockerfile_after_add_user)
+        cont << cb if not_empty?(cb)
+
+      end
+   
+      cb = trigger_listener(:dockerfile_before_workdir)
+      cont << cb if not_empty?(cb)
+
+      if config.is_workdir_given? and is_set_workdir? 
+        cont << "WORKDIR #{config.workdir}"
+        cont << ""
+      end
+
+      cb = trigger_listener(:dockerfile_after_workdir)
+      cont << cb if not_empty?(cb)
+
+
+      cb = trigger_listener(:dockerfile_before_command)
+      cont << cb if not_empty?(cb)
+
+      cont << "CMD [\"#{command.join(",")}\"]" if is_command_given?
+
+      cont.join("\n")
+
+    end
+
+    private
+    def pkg_mgr(config)
+      case config.platform
+      when :debian
+        "apt-get"
+      when :fedora
+        "dnf"
+      else
+        raise Error, "Unknown package manager for platform '#{config.platform}'"
+      end
+    end
+
+    def trigger_listener(evt, *argv)
+      if not @listener.nil?
+        argv << { dfile: self }
+        @listener.call(evt, *argv)
+      end
+    end
+
+  end
+end