dockerun 0.3.5 → 0.4.0

data/lib/dockerun/config.rb

@@ -1,98 +1,68 @@
 
-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
-    end
-
-    def self.remove
-      path = File.join(Dir.getwd, FILENAME)
-      FileUtils.rm(path) if File.exist?(path)
+    def set_workdir(path)
+      @workdir = path 
     end
-
-    def initialize(configHash = {  }, configFileAvail = false)
-      @config = configHash 
-      @images = @config[:images] || {  }
-      @confFileAvail = configFileAvail
-      #@images = {  } if @images.nil?
-    end
-
-    def isConfigFileAvail?
-      @confFileAvail
+    def workdir
+      if @workdir.nil?
+        @workdir = File.join("/opt",File.basename(Dir.getwd))
+      end
+      @workdir
     end
-
-    def image_names
-      @images.keys
+    def is_workdir_given?
+      not_empty?(@workdir)
     end
 
-    def add_image(name)
-      @images[name] = {  } if not_empty?(name) and not @images.keys.include?(name)
-    end
 
-    def remove_image(name)
-      @images.delete(name)
+    def set_platform(val)
+      @platform = val
     end
-
-    def container_names(imageName)
-      @images[imageName].keys
+    def platform
+      if is_empty?(@platform)
+        # wild guess
+        @platform = :debian
+      end
+      @platform
     end
 
-    def container_configs(imageName, name)
-      @images[imageName].nil? ? {} : @images[imageName][name].nil? ? {} : @images[imageName][name]
-    end
 
-    def add_container(imageName, name)
-      @images[imageName] = {  } if @images[imageName].nil?
-      @images[imageName][name] = {} if @images[imageName][name].nil?
+    def set_current_user(bool = true)
+      @set_current_user = bool
     end
-
-    def remove_container(imageName, name)
-      if not @images[imageName].nil?
-        @images[imageName].delete(name) 
-      end
+    def set_current_user?
+      @set_current_user.nil? ? true : @set_current_user
     end
 
-    def add_mount_to_container(imageName, container, mount)
-      add_container(imageName, container)
-      @images[imageName][container][:mount] = [] if @images[imageName][container][:mount].nil?
-      @images[imageName][container][:mount] << mount
-    end
 
-    def container_mount_points(imageName, container)
-      res = @images[imageName][container]
-      if is_empty?(res) or is_empty?(res[:mount])
-        []
+    def activate_context(ctx, &block)
+      case ctx
+      when :rubygems
+        @active_context = Context::Rubygems.new(self)
       else
-        res[:mount]
+        raise Error, "Unknown context '#{ctx}'"
       end
+      @active_context.instance_eval(&block)
+    end
+    def active_context
+      @active_context
     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

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