rummager 0.5.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 16d898882e16fff98a44d7fb1337cecea686894f
+  data.tar.gz: e4ced1135eeaf4be86843c30e14cc43fcc9e67bb
+SHA512:
+  metadata.gz: b0c82166972288d407cb0c1c0518758ef421245cb063500aa74be18373506227958267a99b3743e464a5af69ca1c8d3c77f30e9c1aa136285f7d34718fe89485
+  data.tar.gz: 6b806770648f370378f580ca686109382720d55322efe84bcb92b2c8555a664389722738f04813435d2716481e0d7204baf65a1fda0949c3e0cdeae3040265d8

data/lib/rummager.rb

@@ -0,0 +1,29 @@
+require 'rake'
+require 'logger'
+require 'excon'
+
+module Rummager
+  class << self; attr_accessor :repo_base; end
+end
+
+require 'rummager/containers'
+require 'rummager/images'
+require 'rummager/util'
+
+# allow long runs through Excon, otherwise commands that
+# take a long time will fail due to timeout
+Excon.defaults[:write_timeout] = 10000
+Excon.defaults[:read_timeout] = 10000
+
+# provide Docker verboseness
+if Rake.verbose == true
+  Docker.logger = Logger.new(STDOUT)
+  Docker.logger.level = Logger::DEBUG
+end
+
+task :"clean" => [ :"containers:clean", :"images:clean" ]
+
+task :"clobber" => [ :"containers:clobber", :"images:clobber" ]
+
+
+__END__

data/lib/rummager/containers.rb

@@ -0,0 +1,473 @@
+require 'rake'
+require 'logger'
+require 'rake/tasklib'
+require 'docker'
+require 'date'
+require 'digest'
+require 'json'
+require 'excon'
+require 'time'
+
+# Create and describe generic container operation targets
+namespace :containers do
+    
+    desc "Start background containers"
+    task :"start"
+    
+    desc "Stop background containers"
+    task :"stop"
+    
+    desc "Remove temporary containers"
+    task :"clean"
+    
+    desc "Remove all Docker containters including caches"
+    task :"clobber" => [ :"containers:clean" ]
+    
+end
+    
+module Rummager
+    
+  CNTNR_ARGS_CREATE = {
+    'AttachStdin' => true,
+    'AttachStdout' => true,
+    'AttachStderr' => true,
+    'OpenStdin' => true,
+    'Tty' => true,
+  }
+
+###########################################################
+##
+## Container Handling Pieces
+##
+###########################################################
+
+  # Abstract base class for Container tasks
+  class ContainerTaskBase < Rake::Task
+    attr_accessor :container_name
+
+    def docker_obj
+      begin
+        @container_obj ||= Docker::Container.get(@container_name.to_s)
+      rescue
+      end
+    end
+
+    def has_container?
+      ! docker_obj.nil?
+    end
+
+    def is_running?
+      container_obj.json['State']['Running'] == false
+    end
+
+    def never_ran?
+      if has_container?
+        if docker_obj.json['State']['Running'] == true
+          puts "#{@container_name} is running!"  if Rake.verbose == true
+          false
+        else
+        end
+      else
+        true
+      end
+    end
+
+    def exit_code
+      container_obj.json['State']['ExitCode']
+    end
+    
+  end # ContainerTaskBase
+
+  class ContainerCreateTask < Rummager::ContainerTaskBase
+    attr_accessor :args_create
+    attr_accessor :command
+    attr_accessor :exposed_ports
+    attr_accessor :image_name
+    attr_accessor :repo_base
+    
+    def needed?
+      ! has_container?
+    end
+    
+    def initialize(task_name, app)
+      super(task_name,app)
+      @actions << Proc.new {
+        create_args = @args_create
+        create_args['Image'] = "#{@repo_base}/#{@image_name}:latest"
+        create_args['name'] = @container_name
+        if @command
+          create_args['Cmd'] = @command
+        end
+        if @exposed_ports
+          create_args['ExposedPorts'] = {};
+          @exposed_ports.each do |prt|
+            create_args['ExposedPorts'][prt] = {}
+          end
+        end
+        newcont = Docker::Container.create( create_args )
+        puts "created container '#{@container_name}' -> #{newcont.json}" if Rake.verbose == true
+      }
+    end
+
+  end #ContainerCreateTask
+
+
+  class ContainerStartTask < Rummager::ContainerTaskBase
+    attr_accessor :volumes_from
+    attr_accessor :args_start
+    attr_accessor :binds
+    attr_accessor :port_bindings
+    attr_accessor :publishall
+    attr_accessor :exec_on_start
+    attr_accessor :start_once
+    
+    def needed?
+      if has_container?
+        puts "checking if #{@container_name} is running" if Rake.verbose == true
+        if docker_obj.json['State']['Running'] == false
+          puts "#{@container_name} is NOT running"  if Rake.verbose == true
+          if Time.parse(docker_obj.json['State']['StartedAt']) != Time.parse('0001-01-01T00:00:00Z')
+            puts "#{@container_name} previously ran"  if Rake.verbose == true
+            if @start_once == true
+              puts "#{@container_name} is a start_once container, not needed" if Rake.verbose == true
+              return false
+            end
+          else
+            puts "#{@container_name} has never run" if Rake.verbose == true
+          end
+        else
+          puts "#{@container_name} is running" if Rake.verbose == true
+        end
+      else
+        puts "#{@container_name} doesnt exist" if Rake.verbose == true
+      end
+      true
+    end
+ 
+    def initialize(task_name, app)
+      super(task_name,app)
+      @actions << Proc.new {
+        start_args = @args_start
+        if @volumes_from
+          puts "using VF:#{@volumes_from}"  if Rake.verbose == true
+          start_args.merge!( {'VolumesFrom' => @volumes_from} )
+        end
+        if @binds
+          puts "using BINDS:#{@binds}"  if Rake.verbose == true
+          start_args['Binds'] = @binds
+        end
+        if @port_bindings
+            puts "using PortBindings:#{@port_bindings}"  if Rake.verbose == true
+            start_args['PortBindings'] = @port_bindings
+        end
+        if @publishall
+          start_args['PublishAllPorts'] = true
+        end
+        puts "Starting: #{@container_name}"
+        docker_obj.start( start_args )
+        if @exec_on_start
+          begin
+            puts "issuing exec calls" if Rake.verbose == true
+            exec_on_start.each do |ae|
+              if ae.delete(:hide_output)
+                docker_obj.exec(ae.delete(:cmd),ae)
+              else
+                docker_obj.exec(ae.delete(:cmd),ae) { |stream,chunk| puts "#{chunk}" }
+              end
+              puts "all exec calls complete" if Rake.verbose == true
+            end
+          rescue => ex
+            raise IOError, "exec failed:#{ex.message}"
+          end
+        end # @exec_on_start
+      }
+    end # initialize
+    
+  end #ContainerStartTask
+
+  class ContainerStopTask < Rummager::ContainerTaskBase
+
+    def needed?
+      if has_container?
+          docker_obj.json['State']['Running'] == true
+        else
+          false
+      end
+    end
+
+    def initialize(task_name, app)
+      super(task_name,app)
+      @actions << Proc.new {
+        puts "Stopping #{@container_name}" if Rake.verbose == true
+        docker_obj.stop
+      }
+    end
+    
+  end #ContainerStopTask
+
+
+  class ContainerRMTask < Rummager::ContainerTaskBase
+  
+    def needed?
+      puts "checking needed? for rm:#{@container_name}" if Rake.verbose == true
+      has_container?
+    end
+
+    def initialize(task_name, app)
+      super(task_name,app)
+      @actions << Proc.new {
+        puts "removing container #{@name}:#{docker_obj.to_s}" if Rake.verbose == true
+        docker_obj.delete(:force => true, :v => true)
+      }
+    end #initialize
+
+  end #ContainerRMTask
+
+  class ContainerEnterTask < Rummager::ContainerTaskBase
+    attr_accessor :env_name
+    def needed?
+      true
+    end
+
+    def initialize(task_name, app)
+      super(task_name,app)
+      @actions << Proc.new {
+        puts "Entering: #{@container_name}"
+        exec "docker attach #{docker_obj.id}"
+      }
+    end # initialize
+
+  end #ContainerEnterTask
+
+
+  # Template to generate tasks for Container lifecycle
+  class ClickContainer < Rake::TaskLib
+    attr_accessor :container_name
+    attr_accessor :image_name
+    attr_accessor :repo_base
+    attr_accessor :command
+    attr_accessor :args_create
+    attr_accessor :args_start
+    attr_accessor :volumes_from
+    attr_accessor :binds
+    attr_accessor :exposed_ports
+    attr_accessor :port_bindings
+    attr_accessor :publishall
+    attr_accessor :dep_jobs
+    attr_accessor :exec_on_start
+    attr_accessor :allow_enter
+    attr_accessor :enter_dep_jobs
+    attr_accessor :noclean
+  
+    def initialize(container_name,args={})
+      @container_name = container_name
+      @image_name = args.delete(:image_name) || container_name
+      @repo_base = args.delete(:repo_base) || Rummager.repo_base
+      @command = args.delete(:command)
+      @args_create = args.delete(:args_create) || CNTNR_ARGS_CREATE
+      @args_start = args.delete(:args_start) || {}
+      @volumes_from = args.delete(:volumes_from)
+      @binds = args.delete(:binds)
+      @exposed_ports = args.delete(:exposed_ports)
+      @port_bindings = args.delete(:port_bindings)
+      if (!@exposed_ports.nil? && !@port_bindings.nil?)
+        puts "WARNING: both 'exposed_ports' and 'port_bindings' are defined on #{@container_name}"
+      end
+      @publishall = args.delete(:publishall)
+      @dep_jobs = args.delete(:dep_jobs)
+      @exec_on_start = args.delete(:exec_on_start)
+      @enter_dep_jobs = args.delete(:enter_dep_jobs) || []
+      @allow_enter = args.delete(:allow_enter)
+      @noclean = args.delete(:noclean)
+      if !args.empty?
+        raise ArgumentError, "ClickContainer'#{@container_name}' defenition has unused/invalid key-values:#{args}"
+      end
+      yield self if block_given?
+      define
+    end
+      
+    def define
+      namespace "containers" do
+        namespace @container_name do
+          # create task
+          realcreatetask = Rummager::ContainerCreateTask.define_task :create
+          realcreatetask.container_name = @container_name
+          realcreatetask.image_name = @image_name
+          realcreatetask.repo_base = @repo_base
+          realcreatetask.args_create = @args_create
+          realcreatetask.command = @command
+          realcreatetask.exposed_ports = @exposed_ports
+          Rake::Task["containers:#{@container_name}:create"].enhance( [ :"images:#{@image_name}:build" ] )
+          if @dep_jobs
+            @dep_jobs.each do |dj|
+              Rake::Task["containers:#{@container_name}:create"].enhance( [ :"#{dj}" ] )
+            end
+          end
+
+          # start task
+          starttask = Rummager::ContainerStartTask.define_task :start
+          starttask.container_name = @container_name
+          starttask.args_start = @args_start
+          starttask.volumes_from = @volumes_from
+          starttask.binds = @binds
+          starttask.port_bindings = @port_bindings
+          starttask.publishall = @publishall
+          starttask.exec_on_start = @exec_on_start
+          
+          Rake::Task["containers:#{@container_name}:start"].enhance( [ :"containers:#{@container_name}:create" ] )
+          if @volumes_from
+            @volumes_from.each do |vf|
+              Rake::Task["containers:#{@container_name}:create"].enhance([:"containers:#{vf}:start" ])
+            end
+          end
+          if @allow_enter
+            # build and jump into an environment
+            entertask = Rummager::ContainerEnterTask.define_task :enter
+            entertask.container_name = @container_name
+            @enter_dep_jobs.each do |edj|
+              Rake::Task["containers:#{@container_name}:enter"].enhance([ :"containers:#{@container_name}:jobs:#{edj}" ])
+            end
+            Rake::Task["containers:#{@container_name}:enter"].enhance([ :"containers:#{@container_name}:start" ])
+          end # allow_enter
+
+          # stop task
+          stoptask = Rummager::ContainerStopTask.define_task :stop
+          stoptask.container_name = @container_name
+          Rake::Task[:"containers:stop"].enhance( [ :"containers:#{@container_name}:stop" ] )
+          
+          # Remove task
+          rmtask = Rummager::ContainerRMTask.define_task :rm
+          rmtask.container_name = @container_name
+          Rake::Task["images:#{@image_name}:rmi"].enhance( [ "containers:#{@container_name}:rm" ] )
+          Rake::Task["containers:#{@container_name}:rm"].enhance( [ :"containers:#{@container_name}:stop" ] )
+          
+          if @noclean == true
+            Rake::Task[:"containers:clobber"].enhance( [ :"containers:#{@container_name}:rm" ] )
+          else
+            Rake::Task[:"containers:clean"].enhance( [ :"containers:#{@container_name}:rm" ] )
+          end
+          
+        end # namespace @container_name
+      end # namespace "containers"
+        
+      Rake::Task["containers:#{@container_name}:rm"].enhance( [ :"containers:#{@container_name}:stop" ] )
+      Rake::Task[:"containers:stop"].enhance( [ :"containers:#{@container_name}:stop" ] )
+
+    end # define
+  end # class ClickContainer
+
+
+  class ContainerExecTask < Rummager::ContainerTaskBase
+    attr_accessor :exec_list
+    attr_accessor :ident_hash
+
+    def ident_filename
+      "/.once-#{@ident_hash}"
+    end
+
+    def needed?
+      if ! @ident_hash.nil?
+        puts "checking for #{ident_filename} in container"
+        begin
+          docker_obj.copy("#{ident_filename}")
+          return false
+        rescue
+          puts "#{ident_filename} not found"
+        end
+      end
+      # no ident hash, or not found
+      true
+    end
+    
+    def initialize(task_name, app)
+      super(task_name,app)
+      @actions << Proc.new {
+  
+        @exec_list.each do |e|
+          
+          hide_output = e.delete(:hide_output)
+          cmd = e.delete(:cmd)
+          restart_after = e.delete(:restart_after)
+          
+          if hide_output == true
+            docker_obj.exec(cmd)
+          else
+          docker_obj.exec(cmd) { |stream,chunk| puts "#{chunk}" }
+          end
+        
+          if restart_after==true
+            puts "exec item requires container restart" if Rake.verbose == true
+            docker_obj.restart()
+          end
+          
+        end # @exec_list.each
+
+        if ! @ident_hash.nil?
+          puts "marking #{task_name} completed: #{ident_filename}" if Rake.verbose == true
+          docker_obj.exec(["/usr/bin/sudo","/usr/bin/touch","#{ident_filename}"])
+        end
+
+      }
+      
+    end # initialize
+    
+  end # class ContainerExecTask
+
+
+  class ClickCntnrExec < Rake::TaskLib
+    attr_accessor :job_name
+    attr_accessor :container_name
+    attr_accessor :exec_list
+    attr_accessor :ident_hash
+    attr_accessor :dep_jobs
+    
+    def initialize(job_name,args={})
+      @job_name = job_name
+      if !args.delete(:run_always)
+        @ident_hash = Digest::MD5.hexdigest(args.to_s)
+        puts "#{job_name} ident: #{@ident_hash}" if Rake.verbose == true
+      end
+      
+      @container_name = args.delete(:container_name)
+      if !defined? @container_name
+        raise ArgumentError, "ClickContainer'#{@job_name}' missing comtainer_name:#{args}"
+      end
+      @exec_list = args.delete(:exec_list)
+      @dep_jobs = args.delete(:dep_jobs)
+      if !args.empty?
+        raise ArgumentError, "ClickExec'#{@job_name}' defenition has unused/invalid key-values:#{args}"
+      end
+      yield self if block_given?
+      define
+    end  # initialize
+    
+    
+    def define
+      
+      namespace "containers" do
+        namespace @container_name do
+          namespace "jobs" do
+            
+            exectask = Rummager::ContainerExecTask.define_task :"#{job_name}"
+            exectask.container_name = @container_name
+            exectask.exec_list = @exec_list
+            exectask.ident_hash = @ident_hash
+            Rake::Task[:"containers:#{@container_name}:jobs:#{job_name}"].enhance( [:"containers:#{@container_name}:start"] )
+            if @dep_jobs
+                @dep_jobs.each do |dj|
+                    Rake::Task["containers:#{@container_name}:jobs:#{job_name}"].enhance([ :"containers:#{@container_name}:jobs:#{dj}" ])
+                end
+            end
+            
+          end # namespave "jobs"
+        end # namespace @container_name
+      end # namespace "containers"
+      
+    end # define
+    
+  end # class ClickCntnrExec
+
+
+end   # module Rummager
+
+__END__

data/lib/rummager/images.rb

@@ -0,0 +1,223 @@
+require 'rake'
+require 'logger'
+require 'rake/tasklib'
+require 'docker'
+require 'date'
+require 'digest'
+require 'json'
+require 'excon'
+require 'time'
+require 'rummager/util'
+
+# Create and describe generic image operation targets
+namespace :images do
+  desc "Build all Docker images"
+  task :"build"
+  
+  desc "Remove temporary images"
+  task :"clean" => [ :"containers:clean" ]
+  
+  desc "Remove all Docker images"
+  task :"clobber" => [ :"containers:clobber", :"images:clean" ]
+end
+
+###########################################################
+##
+## Image Handling Pieces
+##
+###########################################################
+
+# Abstract base class for Image handling tasks
+class Rummager::ImageTaskBase < Rake::Task
+  attr_accessor :repo
+  attr_accessor :tag
+  
+  def has_repo?
+    Docker::Image.all(:all => true).any? { |image| image.info['RepoTags'].any? { |s| s.include?(@repo) } }
+  end
+  
+end # ImageTaskBase
+
+# Image build tasks
+class Rummager::ImageBuildTask < Rummager::ImageTaskBase
+  attr_accessor :source
+  attr_accessor :add_files
+  
+  IMG_BUILD_ARGS = {
+  :forcerm => true,
+  :rm => true,
+  }
+  
+  def fingerprint_sources
+    content = nil
+    # grab the source string or source directory as the content
+    if @source.is_a?( String )
+      content = @source
+      # include any added files in the hash
+      if @add_files
+        @add_files.each { |af| content << IO.read(af) }
+      end
+    elsif source.is_a?( Dir )
+      files = Dir["#{source.path}/**/*"].reject{ |f| File.directory?(f) }
+      content = files.map{|f| File.read(f)}.join
+    else
+      raise ArgumentError, "Unhandled argument: #{source.to_s} is not a String or Dir"
+    end
+    # return an MD5 hash sum
+    Digest::MD5.hexdigest(content)
+  end
+  
+  def fingerprint
+    @fingerprint ||= fingerprint_sources
+  end
+  
+  def needed?
+    !Docker::Image.all(:all => true).any? { |image| image.info['RepoTags'].any? { |s| s.include?("#{@repo}:#{fingerprint}") } }
+  end
+  
+  def initialize(task_name, app)
+    super(task_name,app)
+    @build_args = IMG_BUILD_ARGS
+    @actions << Proc.new {
+      @build_args[:'t'] = "#{@repo}:#{fingerprint}"
+      puts "Image '#{@repo}:#{fingerprint}' begin build"
+      
+      if @source.is_a?( Dir )
+        puts "building from dir '#{Dir.to_s}'"
+          newimage = Docker::Image.build_from_dir( @source, @build_args ) do |c|
+            begin
+              print JSON(c)['stream']
+              rescue
+              print "WARN JSON parse error with:" + c
+            end
+          end
+        else
+        puts "building from string/tar"  if Rake.verbose == true
+        tarout = StringIO.new
+        Gem::Package::TarWriter.new(tarout) do |tarin|
+          tarin.add_file('Dockerfile',0640) { |tf| tf.write(@source) }
+          if @add_files
+            @add_files.each do | af |
+              puts "add:#{af} to tarfile"  if Rake.verbose == true
+              tarin.add_file( af, 0640 ) { |tf| tf.write(IO.read(af)) }
+            end
+          end
+        end
+        
+        newimage = Docker::Image.build_from_tar( tarout.tap(&:rewind), @build_args ) do |c|
+          begin
+            print JSON(c)['stream']
+            rescue
+            print "WARN JSON parse error with:" + c
+          end
+        end
+      end
+      newimage.tag( 'repo' => @repo,
+                    'tag' => 'latest',
+                    'force' => true )
+                   puts "Image '#{@repo}': build complete"
+                   puts "#{@build_args} -> #{newimage.json}" if Rake.verbose == true
+    }
+  end #initialize
+  
+end #ImageBuildTask
+
+
+# Image removal tasks
+class Rummager::ImageRMITask < Rummager::ImageTaskBase
+  
+  def needed?
+    has_repo?
+  end
+  
+  def initialize(task_name, app)
+    super(task_name,app)
+    @actions << Proc.new {
+      puts "removing image '#{t.repo}'" if Rake.verbose == true
+      Docker::Image.all(:all => true).each do |img|
+        if img.info['RepoTags'].any? { |s| s.include?(@repo) }
+          begin
+            img.delete(:force => true)
+            rescue Exception => e
+            puts "exception: #{e.message}" if Rake.verbose == true
+          end
+        end
+      end #each
+    }
+  end # initialize
+  
+end #DockerImageRMITask
+
+
+# Template to generate tasks for Docker Images
+class Rummager::ClickImage < Rake::TaskLib
+  
+  attr_accessor :image_name
+  attr_accessor :repo_base
+  attr_accessor :source
+  attr_accessor :add_files
+  attr_accessor :dep_image
+  attr_accessor :dep_other
+  attr_accessor :noclean
+  attr_accessor :image_args
+  
+  def initialize(image_name,args={})
+    @image_name = image_name
+    @repo_base = args.delete(:repo_base) || Rummager.repo_base
+    @source = args.delete(:source)
+    @add_files = args.delete(:add_files)
+    if @source.nil?
+      @source = Dir.new("./#{@image_name}/")
+      puts "no direct source, use #{@source.path}" if Rake.verbose == true
+    end
+    @dep_image = args.delete(:dep_image)
+    @dep_other = args.delete(:dep_other)
+    @noclean = args.delete(:noclean)
+    @image_args = args
+    @image_args[:repo] = "#{@repo_base}/#{image_name}"
+    puts "repo for #{@image_name} will be #{@image_args[:repo]}" if Rake.verbose == true
+    @image_args[:tag] ||= 'latest'
+    yield self if block_given?
+    define
+  end
+  
+  def define
+    namespace "images" do
+      namespace @image_name do
+        
+        rmitask = Rummager::ImageRMITask.define_task :rmi
+        rmitask.repo = "#{@image_args[:repo]}"
+        rmitask.tag = 'latest'
+        
+        buildtask = Rummager::ImageBuildTask.define_task :build
+        buildtask.source = @source
+        buildtask.repo = @image_args[:repo]
+        buildtask.tag = buildtask.fingerprint
+        buildtask.add_files = @add_files
+        
+      end # namespace
+    end # namespace
+    
+    if @dep_image
+      puts "'#{@image_name}' is dependent on '#{@dep_image}'" if Rake.verbose == true
+      # forward prereq for build
+      Rake::Task[:"images:#{@image_name}:build"].enhance( [ :"images:#{@dep_image}:build" ] )
+      # reverse prereq on parent image for delete
+      Rake::Task[:"images:#{@dep_image}:rmi"].enhance(["images:#{@image_name}:rmi"])
+    end
+    if @dep_other
+      Rake.Task[:"images:#{@image_name}"].enhance( @dep_other )
+    end
+    
+    if @noclean
+      Rake::Task[:"images:clobber"].enhance( [ :"images:#{@image_name}:rmi"] )
+      else
+      Rake::Task[:"images:clean"].enhance( [ :"images:#{@image_name}:rmi"] )
+    end
+    
+  end # ClickImage.define
+  
+end # class ClickImage
+
+
+__END__

data/lib/rummager/util.rb

@@ -0,0 +1,39 @@
+module Rummager
+
+    def Rummager.cmd_gitmirror(filepath,giturl)
+        {
+            :cmd=> [ "/bin/bash","-c",
+            "if [[ -d #{filepath} ]]; then\n"                       \
+            "  /usr/bin/git --git-dir=#{filepath} fetch --all\n"    \
+            "else\n"                                                \
+            "  /usr/bin/git clone --mirror #{giturl} #{filepath}\n" \
+            "fi\n"],
+        }
+    end # mirror_or_update
+
+    def Rummager.cmd_gitupdate(filepath)
+        {
+            :cmd=> [ "/bin/bash","-c",
+            "/usr/bin/git --git-dir=#{filepath} fetch --all",
+            ],
+        }
+    end # cmd_gitupdate
+
+    def Rummager.cmd_gitclone(branch,srcpath,clonepath)
+        {
+            :cmd => ["/bin/sh","-c",
+            "/usr/bin/git clone --branch #{branch} #{srcpath} #{clonepath}"
+            ],
+        }
+    end # cmd_gitclone
+
+    def Rummager.cmd_gitcheckout(commithash,srcpath,clonepath)
+        {
+            :cmd => ["/bin/sh","-c",
+            "/usr/bin/git clone --no-checkout #{srcpath} #{clonepath}\n"  \
+            "/usr/bin/git --work-tree #{clonepath} --git-dir #{clonepath}/.git checkout #{commithash}\n"
+            ],
+        }
+    end # cmd_gitclone
+
+end # Rummager

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: rummager
+version: !ruby/object:Gem::Version
+  version: 0.5.3
+platform: ruby
+authors:
+- y3ddet, ted@xassembly.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.21.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.21.0
+description: Rake integration with docker-api
+email: ted@xassembly.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rummager.rb
+- lib/rummager/containers.rb
+- lib/rummager/images.rb
+- lib/rummager/util.rb
+homepage: https://github.com/exactassembly/rummager
+licenses:
+- GPLv2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Rummager
+test_files: []