dockdev 0.3.8 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aef435aebef51b0a8aa6535d4f75b6ea8151bd7c474e15547421cc31d7e4dfbc
-  data.tar.gz: 727d3c78e3c9ae406e4e0dda8c399cced4e86a6c79c4f899d06f626cf365f7d3
+  metadata.gz: dc457c18386138fb748fcc182da23a0a53613bcdfad90288ff2e4f553fe81ab7
+  data.tar.gz: 6a9d639a8a4a09f76c3948cead657f50688e42c0aaada6f45222dd766b45e947
 SHA512:
-  metadata.gz: 81a9a8152486d15d21db57fcaf83a95480bd948c500c28aef61bb3b1f321d5d2d39c5c1d07eb782905ff48b3e763a1db9bf284da78dcc3258d172b6e237684b7
-  data.tar.gz: 1f9a94feef8e90938743c97623671dcf37ee96153723db7e3f1964c2d0ca08ef8cfbf2bdabc78946c33f37dcbb002a1106c42c6e3b3958a60463e62826876809
+  metadata.gz: fa1e22aafc5d128eef30ab82e3b5545d616efda9c30eccc5e85a414aa0638b260be020d3d4d376cceeca0197417f3b9f61098c7fbd607f68576e218ce00e40aa
+  data.tar.gz: 677f6dcc88a354185760d1abed3064f8292352ae9f6efb08c4493f1ac42f45eccdb25e70e5ea4b71708aa2cd458ce42de6d3704edcbc658b812f7d257a58e768

data/exe/dockdev

@@ -7,13 +7,19 @@
 
 require_relative '../lib/dockdev'
 
-contName = ARGV.first || File.basename(Dir.getwd)
-cmd = ARGV[1]
+#contName = ARGV.first || File.basename(Dir.getwd)
+#cmd = ARGV[1]
+#input = ARGV[1]
+
+uconf = Dockdev::UserConfig.new(ARGV.first)
+contName = uconf.container_name || File.basename(Dir.getwd)
 
 begin
-  Dockdev.with_running_container(contName, command: cmd, root: Dir.getwd)
+  #Dockdev.with_running_container(contName, command: cmd, root: Dir.getwd)
+  Dockdev.with_running_container(contName, user_config: uconf, root: Dir.getwd)
 rescue StandardError => ex
   STDERR.puts ex.message
+  STDERR.puts ex.backtrace.join("\n")
 end
 
 

data/lib/dockdev/container.rb

@@ -69,5 +69,6 @@ module Dockdev
       end
     end
 
+
   end
 end

data/lib/dockdev/context/docker-compose.rb

@@ -88,14 +88,20 @@ module Dockdev
         [@mounts, @ports]
       end
 
-      def process_mount(opts = {}, &block)
-        mounts, _ = parse_docker_compose
-        mounts
-      end
+      def apply_context(dockdev_config)
+        ddConf = dockdev_config
+        
+        if not ddConf.nil?
+          mounts, ports = parse_docker_compose
+          mounts.each do |host, docker|
+            ddConf.add_mount(host, docker)
+          end
+          ports.each do |host, docker|
+            ddConf.add_port(host, docker)
+          end
+        end
 
-      def process_port(opts = {}, &block)
-        _, ports = parse_docker_compose
-        ports
+        ddConf
       end
 
       private

data/lib/dockdev/context/rubygems.rb

@@ -4,6 +4,7 @@ require 'bundler'
 module Dockdev
   module Context
     class Rubygems
+      include TR::CondUtils
 
       def self.init_path(path)
         Rubygems.new(path)
@@ -23,15 +24,10 @@ module Dockdev
         Dir.glob(File.join(@path,"Gemfile"))
       end
 
-      def process_mount(opts = { dir_inside_docker: "/opt" })
+      def apply_context(dockdev_config)
+        ddConf = dockdev_config
 
-        if @mounts.empty?
-
-          dir_inside_docker = opts[:dir_inside_docker]
-
-          script = ["#!/bin/bash"]
-          #script << "alias be > /dev/null 2>&1 && echo 'alias be=bundle exec' >> ~/.bashrc"
-          script << "echo 'alias be=\"bundle exec\"' >> ~/.bashrc"
+        if not_empty?(ddConf)
 
           # 
           # looking at source code 
@@ -39,33 +35,91 @@ module Dockdev
           # seems this is the way to set root for Bundler
           #
           ENV['BUNDLE_GEMFILE'] = find_gemfile.first
-          Bundler.load.dependencies.each do |d|
-            if not d.source.nil?
-              src = d.source
-              if src.path.to_s != "."
-                pathInsideDocker = File.join(dir_inside_docker, d.name)
-                @mounts[src.path.expand_path.to_s] = pathInsideDocker
-                script << "bundle config --global local.#{d.name} #{pathInsideDocker}"
-                #res[d.name] = src.path.expand_path.to_s
+          if not_empty?(ENV['BUNDLE_GEMFILE'])
+
+            cmd = ["echo 'alias be = \"bundle exec\"' >> /etc/bash.bashrc"]
+
+            Bundler.load.dependencies.each do |d|
+              if not d.source.nil?
+                src = d.source
+                if src.path.to_s != "."
+                  pathInsideDocker = File.join(ddConf.workdir, d.name)
+                  ddConf.add_mount(src.path.expand_path.to_s,pathInsideDocker)
+                  # following line assumed 'bundle' program already installed inside the image
+                  cmd << "bundle config --global local.#{d.name} #{pathInsideDocker}"
+                end
               end
             end
-          end
 
-          scriptOut = File.join(@path,"to-be-executed-once-inside-docker.sh") 
-          File.open(scriptOut,"w") do |f|
-            f.write script.join("\n")
+            if not_empty?(cmd)
+            
+              script = ["#!/bin/bash"]
+              script << "if ! command -v bundle &> /dev/null"
+              script << "  echo \"Command 'bundle' is available!\""
+              script.concat(cmd.collect { |e| "  #{e}"})
+              script << "then"
+              script << "  echo \"Command 'bundle' not available\""
+              #script << "   exit 1"
+              script << "fi"
+
+              File.open("rubygems_init.sh","w") do |f|
+                f.write script.join("\n")
+              end
+
+              ddConf.append_Dockerfile("COPY rubygems_init.sh /tmp/rubygems_init.sh") 
+              ddConf.append_Dockerfile("RUN chmod +x /tmp/rubygems_init.sh && /tmp/rubygems_init.sh") 
+            end
+
           end
-          `chmod +x #{scriptOut}`
 
         end
 
-        @mounts
-
+        ddConf
       end
 
-      def process_port(opts = {})
-        @ports
-      end
+      #def process_mount(opts = { dir_inside_docker: "/opt" })
+
+      #  if @mounts.empty?
+
+      #    dir_inside_docker = opts[:dir_inside_docker]
+
+      #    script = ["#!/bin/bash"]
+      #    #script << "alias be > /dev/null 2>&1 && echo 'alias be=bundle exec' >> ~/.bashrc"
+      #    script << "echo 'alias be=\"bundle exec\"' >> ~/.bashrc"
+
+      #    # 
+      #    # looking at source code 
+      #    # https://github.com/rubygems/rubygems/blob/master/bundler/lib/bundler/shared_helpers.rb#L246
+      #    # seems this is the way to set root for Bundler
+      #    #
+      #    ENV['BUNDLE_GEMFILE'] = find_gemfile.first
+      #    Bundler.load.dependencies.each do |d|
+      #      if not d.source.nil?
+      #        src = d.source
+      #        if src.path.to_s != "."
+      #          pathInsideDocker = File.join(dir_inside_docker, d.name)
+      #          @mounts[src.path.expand_path.to_s] = pathInsideDocker
+      #          script << "bundle config --global local.#{d.name} #{pathInsideDocker}"
+      #          #res[d.name] = src.path.expand_path.to_s
+      #        end
+      #      end
+      #    end
+
+      #    scriptOut = File.join(@path,"to-be-executed-once-inside-docker.sh") 
+      #    File.open(scriptOut,"w") do |f|
+      #      f.write script.join("\n")
+      #    end
+      #    `chmod +x #{scriptOut}`
+
+      #  end
+
+      #  @mounts
+
+      #end
+
+      #def process_port(opts = {})
+      #  @ports
+      #end
 
     end
   end

data/lib/dockdev/context.rb

@@ -14,12 +14,26 @@ module Dockdev
         @ctx[name] = cls
       end
 
+      def registered_context
+        @ctx.keys.freeze
+      end
+
+      def registered_context_by_name(name, path)
+        ctx = @ctx[id]
+        if not ctx.nil?
+          ctx.init_path(path) 
+        end
+
+        ctx
+      end
+
       def get_context(path)
-        ctx = []
-        @ctx.values.each do |v|
+        ctx = {}
+        @ctx.each do |k, v|
           vv = v.init_path(path)
           if vv.is_context?
-            ctx << vv
+            #ctx << vv
+            ctx[k] = vv
           end
         end
         ctx

data/lib/dockdev/dockdev_config.rb

@@ -0,0 +1,311 @@
+
+require 'toolrack'
+
+module Dockdev
+
+
+  ## Support multiple Dockerfile different configurations
+  ##   Default config is the default Dockerfile file name
+  #class Configs
+  #  include TR::CondUtils
+
+  #  def initialize
+  #    @configs = { default: Config.new }
+  #  end
+
+  #  def config_names
+  #    @configs.keys.freeze
+  #  end
+
+  #  def default_config_name
+  #    :default
+  #  end
+
+  #  def default_config
+  #    @configs[:default]
+  #  end
+
+  #  def config(name)
+  #    indx = File.basename(name)
+  #    indx = :default if indx == "Dockerfile"
+
+  #    conf = @configs[indx]
+  #    if conf.nil?
+  #      conf = Config.new 
+  #      @configs[indx] = conf
+  #    end
+  #    conf
+  #  end
+
+  #  def is_config_exist?(name)
+  #    not_empty?(config(name))
+  #  end
+
+  #  private
+  #  def method_missing(mtd, *args, &block)
+  #    default_config.send(mtd, *args, &block)
+  #  end
+  #end # end class Configs
+
+  # Content of the config file 
+  #   which shall configure the to be run docker instance
+  #   Hence mostly the accessors/readers are related to docker configuration items
+  class Config
+    include TR::CondUtils
+
+    # for image
+    attr_accessor :workdir
+
+    # for container
+    attr_reader :mounts, :ports
+    attr_accessor :network
+    
+    # for image
+    attr_reader :dockerfile_entries
+
+    # since context activation is automated:
+    # 1. skip_context shall skip all found automated activated context
+    # 2. activate_context shall add those context which is not found by automated discovery
+    attr_reader :skip_context, :activate_context
+    def initialize(val = {})
+      @mounts = val[:mounts] || {}
+      @ports = val[:ports] || {}
+      @network = val[:network] || nil
+      @dockerfile_entries = val[:dockerfile_entries] || []
+      @workdir = val[:workdir] || "/opt"
+      @skip_context = val[:skip_context] || []
+      @activate_context = val[:activate_context] || []
+    end
+
+
+    # Convert internal value into hash to be written to file to get rid of the object 
+    #   encoding in the yaml file
+    def to_storage
+      { mounts: @mounts, ports: @ports, dockerfile_entries: @dockerfile_entries, workdir: @workdir, skip_context: @skip_context, activate_context: @activate_context }
+    end
+
+
+    # Add mount mapping of host => docker follows docker-cli which follows
+    #   docker cli -v format
+    #
+    # @param on_host [String] path on host
+    # @param on_docker [String] path on docker
+    # @param opts [Hash] options for the mount spec definition. Value keys including:
+    # @option opts [Symbol] :duplicated_entry_policy :error (default) raise error if the on_host is duplicated/already defined
+    # @option opts [Symbol] :duplicated_entry_policy :warn_replace raise warning if the on_host is duplicated/already defined and new entry shall replace the old entry
+    # @option opts [Symbol] :duplicated_entry_policy :warn_discard raise warning if the on_host is duplicated/already defined and new entry is discarded
+    def add_mount(on_host, on_docker, opts = { duplicated_entry_policy: :error })
+      if not_empty?(on_host) and not_empty?(on_docker)
+        if @mounts.keys.include?(on_host)
+          policy = opts[:duplicated_entry_policy] || :error 
+          case policy
+          when :warn_replace
+            logger.warn "on_host '#{on_host}' was mapped to '#{@mounts[on_host]}'. It shall be replaced with '#{on_docker}'"    
+            @mounts[on_host] = on_docker 
+
+          when :warn_discard
+            logger.warn "on_host '#{on_host}' already mapped to '#{@mounts[on_host]}'. New value on_docker is ignored."    
+
+          else
+            # default policy always raise error
+            raise Error, "on_host '#{on_host}' already mapped to '#{@mounts[on_host]}'"
+          end
+        else
+          @mounts[on_host] = on_docker 
+        end
+      else
+        logger.debug "add_mount unsuccessful = on_host : #{on_host} / on_docker : #{on_docker}"
+        raise Error, "on_host mount entry cannot be empty" if is_empty?(on_host)
+        raise Error, "on_docker mount entry cannot be empty" if is_empty?(on_docker)
+      end
+    end
+
+
+    # Add port mapping of host => docker follows docker-cli which follows
+    #   docker cli -p format
+    #
+    # @param on_host [String] port on host
+    # @param on_docker [String] port on docker
+    # @param opts [Hash] options for the port spec definition. Value keys including:
+    # @option opts [Symbol] :duplicated_entry_policy :error (default) raise error if the on_host is duplicated/already defined
+    # @option opts [Symbol] :duplicated_entry_policy :warn_replace raise warning if the on_host is duplicated/already defined and new entry shall replace the old entry
+    # @option opts [Symbol] :duplicated_entry_policy :warn_discard raise warning if the on_host is duplicated/already defined and new entry is discarded
+    def add_port(on_host, on_docker, opts = { duplicated_entry_policy: :error })
+      if not_empty?(on_host) and not_empty?(on_docker)
+        if @ports.keys.include?(on_host)
+          policy = opts[:duplicated_entry_policy] || :error 
+          case policy
+          when :warn_replace
+            logger.warn "on_host '#{on_host}' was mapped to '#{@mounts[on_host]}'. It shall be replaced with '#{on_docker}'"    
+            @ports[on_host] = on_docker 
+
+          when :warn_discard
+            logger.warn "on_host '#{on_host}' already mapped to '#{@mounts[on_host]}'. New value on_docker is ignored."    
+
+          else
+            # default policy always raise error
+            raise Error, "on_host '#{on_host}' already mapped to '#{@mounts[on_host]}'"
+          end
+        else
+          @ports[on_host] = on_docker 
+        end
+      else
+        logger.debug "add_port unsuccessful = on_host : #{on_host} / on_docker : #{on_docker}"
+        raise Error, "on_host port entry cannot be empty" if is_empty?(on_host)
+        raise Error, "on_docker port entry cannot be empty" if is_empty?(on_docker)
+      end
+
+    end
+
+    # Any instruction to be appended into Dockerfile.
+    #   Note this did not presume the entry is RUN, COPY or anyting. 
+    #   A full valid Dockerfile entry has to be provided here
+    #
+    # @param st [String] Full valid Dockerfile line to be embed into Dockerfile
+    def append_Dockerfile(st)
+      logger.debug "Appending : #{st}"
+      @dockerfile_entries << st
+    end
+
+    def is_context_should_skip?(name)
+      @skip_context.include?(name)
+    end
+
+
+    def manual_activated_context
+      @activate_context.freeze
+    end
+
+
+    private
+    def logger
+      Dockdev.logger(:config)
+    end
+
+    def has_additional_entries?
+      not @dockerfile_entries.empty?
+    end
+  end
+
+  # Managing the config
+  class DockdevConfig
+    include TR::CondUtils
+
+    DOCDEV_CONFIG_FILE = "dockdev-config"
+
+    def self.load(root = Dir.getwd, &block)
+      confFile = Dir.glob(File.join(root,"#{DOCDEV_CONFIG_FILE}.*")).grep(/.yml|.yaml$/)
+      if confFile.length > 1
+        block.call(:found_more, contFile)
+      elsif confFile.length == 0
+        block.call(:not_found)
+      else
+        block.call(:found, confFile.first)
+      end
+    end
+
+    def initialize(conf = nil)
+      logger.debug "Given to initialize : #{conf}"
+      if not_empty?(conf)
+        @config = parse(conf)
+      else
+        @config = Config.new
+      end
+    end
+
+
+    def save(root = Dir.getwd)
+      path = File.join(root,"#{DOCDEV_CONFIG_FILE}.yml")
+      File.open(path,"w") do |f|
+        f.write YAML.dump(@config.to_storage)      
+      end
+      path
+    end
+
+
+    # Build the docker image by embedding additional entries into the Dockerfile. 
+    #   This likely will need a temporary file to be created and it should be managed by
+    #   this operation.
+    #
+    # @param [Dockdev::Image] image instance
+    # @param [String] path to selected Dockerfile
+    def build_image(image, dockerfile_path, opts = { root: Dir.getwd }, &block)
+
+      if has_additional_entries?
+
+        logger.debug "dockdev_config has additional entry for Dockerfile. Merging additional entries into Dockerfile"
+
+        root = opts[:root] || Dir.getwd
+        # make it static name so: 
+        # 1. No file removal is required
+        # 2. Allow debug on generated Dockerfile
+        # 3. Replace Dockerfile on each run and only single Dockerfile is left on system
+        # 4. Allow this temporary to be added to .gitignore
+        tmpFile = File.join(root, "#{File.basename(dockerfile_path)}-dockdev")
+        File.open(tmpFile,"w") do |f|
+          found = false
+          File.open(dockerfile_path,"r").each_line do |line|
+            # detecting the CMD line if there is any
+            if line =~ /^CMD/
+              found = true
+              # here we append the lines
+              dockerfile_entries.each do |al|
+                f.puts al
+              end
+              f.write line
+
+            else
+              f.write line
+
+            end
+          end
+
+          if not found
+            @dockerfile_entries.each do |al|
+              f.puts al
+            end
+          end
+
+        end
+
+        image.build(tmpFile)
+
+      else
+        logger.debug "dockdev_config has no additional entry for Dockerfile. Proceed to build found Dockerfile"
+        image.build(dockerfile_path)
+      end
+
+    end
+
+
+    private
+    def parse(conf)
+      logger.debug "Given to parse : #{conf}"
+      cont = File.read(conf) 
+      val = YAML.unsafe_load(cont)
+      Config.new(val)
+    end
+
+    def method_missing(mtd, *args, &block)
+      logger.debug "method_missing '#{mtd}' / #{args}"
+      @config.send(mtd, *args, &block)
+    end
+
+    def logger
+      Dockdev.logger(:dockdev_config)
+    end
+
+  end
+end
+
+
+if $0 == __FILE__
+
+  require_relative '../dockdev'
+
+  c = Dockdev::DockdevConfig.new
+  c.add_mount("/Users/chris/01.Workspaces/02.Code-Factory/08-Workspace/docker-cli","/opt/docker-cli")
+  c.save
+end
+
+

data/lib/dockdev/image.rb

@@ -53,10 +53,12 @@ module Dockdev
         dockerfile: dockerfilePath
       }
       optss.merge!(opts)
-      @cmd_fact.build_image(@image_name, optss).run
+      res = @cmd_fact.build_image(@image_name, optss).run
 
       FileUtils.rm(generated_dockerfile) if File.exist?(generated_dockerfile) and not is_keep_generated_dockerfile?
 
+      res
+
     end
 
     def destroy

data/lib/dockdev/version.rb

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

data/lib/dockdev/workspace.rb

@@ -12,11 +12,27 @@ module Dockdev
     end
 
     def has_dockerfile?
-      Dir.glob(File.join(@root,"Dockerfile")).length > 0
+      found_dockerfile_count > 0
+    end
+
+    def found_dockerfile_count
+      dockerfiles.length 
+    end
+
+    def has_multiple_dockerfiles?
+      found_dockerfile_count > 1
+    end
+
+    def dockerfiles
+      Dir.glob(File.join(@root,"Dockerfile*"))
     end
 
     def dockerfile
-      Dir.glob(File.join(@root,"Dockerfile")).first
+      if has_dockerfile?
+        dockerfiles.first
+      else
+        nil
+      end
     end
 
     def has_docker_compose?

data/lib/dockdev.rb

@@ -5,82 +5,217 @@ require 'toolrack'
 require 'docker/cli'
 require 'colorize'
 
+require 'tty/prompt'
+
 require_relative "dockdev/version"
 
 require_relative 'dockdev/workspace'
 require_relative 'dockdev/image'
 require_relative 'dockdev/container'
 
+require_relative 'dockdev/dockdev_config'
+
+require_relative 'dockdev/user_config'
+
 module Dockdev
   include TR::CondUtils
 
   class Error < StandardError; end
   # Your code goes here...
 
+  # main entry points to start docker
   def self.with_running_container(contName, opts = {})
 
+    pmt = TTY::Prompt.new
     root = opts[:root]
-    cmd = opts[:command]
+    cmd = opts[:command] || ""
 
-    ctx = Dockdev::Context::ContextManager.instance.get_context(root)
-    logger.debug("Found context : #{ctx}")
+    ddConf = load_config(root)
+
+    user_config = opts[:user_config]
 
     cont = Container.new(contName)
     if cont.has_container?
+      
+      logger.debug "Container '#{contName}' already exist. Just run the container"
       if cont.running?
         cont.attach_and_exec(command: cmd)
       else
         cont.start_with_command(command: cmd)
       end
+
     else
+      
+      logger.debug "Container '#{contName}' does not exist. Creating the container"
+
       img = Image.new(contName)
       ws = opts[:workspace] || root
       wss = Workspace.new(ws)
-      if img.has_image?
-        mount = { root => File.join("/opt",File.basename(root)) }
-        port = {}
-        ctx.each do |cctx|
-          mnts = cctx.process_mount(dir_inside_docker: "/opt")
-          logger.debug "Mount points by context : #{mnts}"
 
-          mount.merge!(mnts) if not mnts.empty?
+      # root directory is mounted by default
+      ddConf.add_mount(root, File.join(ddConf.workdir,File.basename(root)))
 
-          prt = cctx.process_port
-          port.merge!(prt) if not prt.empty?
+      if user_config.has_key?(:network)
+        ddConf.network = user_config.network
+      end
+
+      ctx = Dockdev::Context::ContextManager.instance.get_context(root)
+      logger.debug("Found context : #{ctx}")
+
+      ctx.each do |name, cctx|
 
-          logger.debug "Ports by context #{cctx} : #{prt}"
+        if ddConf.is_context_should_skip?(name)
+          logger.debug "Context '#{name}' is asked to be skipped"
+          next
         end
 
-        param = { command: cmd, mounts: mount }
-        param[:ports] = port if not port.empty? 
+        logger.debug "Appying context '#{name}' "
+        # here allow context to add additional Dockerfile entries, mounts and ports
+        ddConf = cctx.apply_context(ddConf)
+      end
 
-        img.new_container(cont.name, param)
+      ddConf.manual_activated_context.each do |cctx|
+        mctx = Dockdev::Context::ContextManager.instance.registered_context_by_name(cctx)
+        logger.debug "Executing manual activated context : #{mctx}"
+        ddConf = mctx.apply_context(ddConf) if not mctx.nil?
+      end
 
-      elsif wss.has_dockerfile?
-        img.build(wss.dockerfile)
-        
-        mount = { root => File.join("/opt",File.basename(root)) }
-        port = {}
-        ctx.each do |cctx|
-          mnt = cctx.process_mount(dir_inside_docker: "/opt")
-          mount.merge!(mnt) if not mnt.empty?
+      if not img.has_image? 
 
-          logger.debug "Mount points by context #{cctx} : #{mnt}"
+        if wss.has_dockerfile?
 
-          prt = cctx.process_port
-          port.merge!(prt) if not prt.empty?
+          if wss.has_multiple_dockerfiles?
 
-          logger.debug "Ports by context #{cctx} : #{prt}"
-        end
+            selDockerFile = pmt.select("Please select one of the Dockerfile to proceed : ") do |m|
+              wss.dockerfiles.each do |df|
+                m.choice File.basename(df), df
+              end
+            end
 
-        param = { command: cmd, mounts: mount }
-        param[:ports] = port if not port.empty? 
+          else
+            selDockerFile = wss.dockerfile
+          end
 
-        img.new_container(cont.name, param)
+          # Delegated to config file to allow
+          # config file to embed addtional entries (if there is any) and proceed to build it.
+          # During the process it is very likey a temporary Dockerfile shall be created since 
+          # docker cli works on file basis and this temporary file need to be managed after the process.
+          # Hence this makes more sense to let the config handle all those inside the operation
+          res = ddConf.build_image(img, selDockerFile, root: root) 
+          raise Error, "Image failed to be built. Error was : #{res.err_stream}" if res.failed?
+          STDOUT.puts "\n Image '#{contName}' built successfully\n\n".green
+          #img.build(wss.dockerfile)
 
-      else
-        raise Error, "\n No image and no Dockerfile found to build the image found. Operation aborted. \n\n".red
+        else
+          raise Error, "\n No image and no Dockerfile found to build the image. Operation aborted. \n\n".red
+
+        end
+      end
+
+      # image already exist!
+      # Since reach here means container doesn't exist yet.
+      # Proceed to create container
+
+      param = { command: cmd, mounts: ddConf.mounts, ports: ddConf.ports }
+      if not_empty?(ddConf.network)
+        cmd_fact = Docker::Cli::CommandFactory.new
+        res = cmd_fact.create_network(ddConf.network).run
+        if res.success? and not res.is_out_stream_empty?
+          param[:network] = ddConf.network 
+        else
+          err = res.err_stream
+          if err =~ /already exist/
+            param[:network] = ddConf.network 
+          else
+            raise Error, "\n Failed to create network. Error was : #{res.err_stream}\n"
+          end
+        end
       end
+      img.new_container(cont.name, param)
+
+      #if img.has_image?
+      #  
+      #  # has image but no container
+      #  ctx.each do |cctx|
+      #   
+      #    ddConf = cctx.apply_context(ddConf)
+
+      #    #cctx.process_mount(dir_inside_docker: ddConf.workdir).each do |host,docker|
+      #    #  logger.debug "Mount points by context '#{cctx}' : #{host} => #{docker}"
+      #    #  ddConf.add_mount(host, docker)
+      #    #end
+
+      #    #cctx.process_port.each do |host, docker|
+      #    #  logger.debug "Ports mapping by context '#{cctx}' : #{host} => #{docker}"
+      #    #  ddConf.add_port(host, docker)
+      #    #end
+
+      #    #mnts = cctx.process_mount(dir_inside_docker: ddConf.workdir)
+      #    #logger.debug "Mount points by context : #{mnts}"
+
+      #    #mount.merge!(mnts) if not mnts.empty?
+
+      #    #prt = cctx.process_port
+      #    #port.merge!(prt) if not prt.empty?
+
+      #    #logger.debug "Ports by context #{cctx} : #{prt}"
+      #  end
+
+      #  #param = { command: cmd, mounts: mount }
+      #  #param[:ports] = port if not port.empty? 
+      #  param = { command: cmd, mounts: ddConf.mounts, ports: ddConf.ports }
+
+      #  img.new_container(cont.name, param)
+
+      #elsif wss.has_dockerfile?
+
+      #  logger.debug "Dockerfile '#{wss.dockerfile}' found. Proceed building the image."
+
+      #  # Delegated to config file to allow
+      #  # config file to embed addtional entries (if there is any) and proceed to build it.
+      #  # During the process it is very likey a temporary Dockerfile shall be created since 
+      #  # docker cli works on file basis and this temporary file need to be managed after the process.
+      #  # Hence this makes more sense to let the config handle all those inside the operation
+      #  ddConf.build_image(img, wss, root: root)
+      #  #img.build(wss.dockerfile)
+      # 
+      #  ddConf.add_mount(root, File.join(ddConf.workdir,File.basename(root)))
+      #  #mount = { root => File.join(ddConf.workdir,File.basename(root)) }
+      #  #port = {}
+      #  ctx.each do |cctx|
+
+      #    ddConf = cctx.apply_context(ddConf)
+
+      #    #cctx.process_mount(dir_inside_docker: ddConf.workdir).each do |host,docker|
+      #    #  logger.debug "Mount points by context '#{cctx}' : #{host} => #{docker}"
+      #    #  ddConf.add_mount(host, docker)
+      #    #end
+
+      #    #cctx.process_port.each do |host, docker|
+      #    #  logger.debug "Ports mapping by context '#{cctx}' : #{host} => #{docker}"
+      #    #  ddConf.add_port(host, docker)
+      #    #end
+
+      #    #mnt = cctx.process_mount(dir_inside_docker: ddConf.workdir)
+      #    #mount.merge!(mnt) if not mnt.empty?
+
+      #    #logger.debug "Mount points by context #{cctx} : #{mnt}"
+
+      #    #prt = cctx.process_port
+      #    #port.merge!(prt) if not prt.empty?
+
+      #    #logger.debug "Ports by context #{cctx} : #{prt}"
+      #  end
+
+      #  #param = { command: cmd, mounts: mount }
+      #  #param[:ports] = port if not port.empty? 
+      #  param = { command: cmd, mounts: ddConf.mounts, ports: ddConf.ports }
+
+      #  img.new_container(cont.name, param)
+
+      #else
+      #  raise Error, "\n No image and no Dockerfile found to build the image found. Operation aborted. \n\n".red
+      #end
     end
   end
 
@@ -99,6 +234,33 @@ module Dockdev
 
   end
 
+  # detect if the additional configuration file exist
+  def self.load_config(root)
+ 
+    ddConf = DockdevConfig.new
+    DockdevConfig.load(root) do |ops, *args|
+      case ops
+      when :found_more
+        found = args.first
+        pmt = TTY::Prompt.new
+        selConf = pmt.select("There are more config files found. Please select one of the files below :") do |m|
+          found.each do |f|
+            m.choice Pathname.new(f).relative_path_from(root),f
+          end
+        end
+        ddConf = DockdevConfig.new(selConf)
+      when :found
+        ddConf = DockdevConfig.new(args.first)
+      else
+      logger.debug "Load config got ops : #{ops}"
+      end
+    end
+
+    logger.debug "Loaded config : #{ddConf}"
+    ddConf
+    
+  end
+
   def self.logger(tag = nil, &block)
     if @_logger.nil?
       @_logger = TeLogger::Tlogger.new(STDOUT)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dockdev
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.1
 platform: ruby
 authors:
 - Chris
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-17 00:00:00.000000000 Z
+date: 2024-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: teLogger
@@ -128,6 +128,7 @@ files:
 - lib/dockdev/context.rb
 - lib/dockdev/context/docker-compose.rb
 - lib/dockdev/context/rubygems.rb
+- lib/dockdev/dockdev_config.rb
 - lib/dockdev/image.rb
 - lib/dockdev/user_info.rb
 - lib/dockdev/version.rb
@@ -136,7 +137,7 @@ files:
 homepage: ''
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -151,8 +152,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.5.1
+signing_key:
 specification_version: 4
 summary: ''
 test_files: []