simp-rake-helpers 3.0.2 → 3.1.0

data/lib/simp/rake/build/tar.rb

@@ -11,17 +11,25 @@ module Simp::Rake::Build
 
     def initialize( base_dir )
       init_member_vars( base_dir )
+
       define_tasks
     end
 
     # define rake tasks
     def define_tasks
       namespace :tar do
+        task :prep do
+          if $simp6
+            @build_dir = $simp6_build_dir
+          end
 
-        directory "#{@dvd_dir}/staging"
+          if $tarball_tgt
+            @dvd_dir = File.dirname($tarball_tgt)
+          end
+        end
 
         def get_simp_version
-          simp_rpm = Dir.glob("#{@base_dir}/build/SIMP/RPMS/*/simp-[0-9]*.rpm").max_by {|f| File.mtime(f)}
+          simp_rpm = Dir.glob("#{@build_dir}/SIMP/RPMS/*/simp-[0-9]*.rpm").max_by {|f| File.mtime(f)}
           fail("Could not find simp main RPM in output directory!") unless simp_rpm
           simp_version = File.basename(simp_rpm).gsub(".noarch.rpm","").gsub("simp-","")
 
@@ -35,8 +43,9 @@ module Simp::Rake::Build
         # Main tasks
         ##############################################################################
 
-        task :validate do |t,args|
-          rpm_dir = File.join(@base_dir,'build','SIMP','RPMS')
+        task :validate => [:prep] do |t,args|
+          rpm_dir = File.join(@build_dir,'SIMP','RPMS')
+
           fail("Could not find output dir: '#{rpm_dir}'") unless File.directory?(rpm_dir)
 
           required_rpms = {
@@ -88,43 +97,58 @@ module Simp::Rake::Build
 
           validate_in_mock_group?
 
+          if $tarball_tgt
+            target_dists = ['simp6']
+          else
+            target_dists = @target_dists
+          end
+
           Parallel.map(
-            @target_dists,
+            target_dists,
             :in_processes => get_cpu_limit,
             :process => t.name
           ) do |dist|
-            base_dir = "#{@dvd_dir}/#{dist}/staging"
+            if $tarball_tgt
+              base_dir = "#{@dvd_dir}/staging"
+            else
+              base_dir = "#{@dvd_dir}/#{dist}/staging"
+            end
+
             destdir = "#{base_dir}/SIMP"
 
             # Build the staging area
+            remove_entry_secure(destdir) if File.exist?(destdir)
+
             mkdir_p(destdir)
+
             Simp::RPM.copy_wo_vcs(@dvd_src,".",base_dir)
 
             # Copy in the GPG Public Keys
             mkdir_p("#{destdir}/GPGKEYS")
-            ln(Dir.glob("#{@build_dir}/GPGKEYS/RPM-GPG-KEY*"), "#{destdir}/GPGKEYS", :force => true)
+            ln(Dir.glob("#{@build_dir}/GPGKEYS/RPM-GPG-KEY*"), "#{destdir}/GPGKEYS", { :force => true })
 
             # Copy in the auto-build RPMs
             Dir.chdir("#{@build_dir}/SIMP/RPMS") do
               Dir.glob('*').each do |type|
                 dest_type = type
-                if File.directory?(type) then
-                  if type =~ /i.*86/ then
+                if File.directory?(type)
+                  if type =~ /i.*86/
                     dest_type = 'i386'
                   end
 
                   mkdir_p("#{destdir}/#{dest_type}")
+
                   Dir.chdir(type) do
-                    ln(Dir.glob("*.#{type}.rpm"),"#{destdir}/#{dest_type}", :force => true)
+                    ln(Dir.glob("*.#{type}.rpm"), "#{destdir}/#{dest_type}", { :force => true })
                   end
                 end
               end
             end
 
-            if args.docs.casecmp('true') == 0 then
+            if args.docs.casecmp('true') == 0
               # Finally, the PDF docs if they exist.
               pdfs = Dir.glob("#{@src_dir}/doc/pdf/*")
-              if ! pdfs.empty? then
+              unless pdfs.empty?
                 pdfs.each do |pdf|
                   cp(pdf,base_dir)
                 end
@@ -132,8 +156,8 @@ module Simp::Rake::Build
                 # If we don't have PDFs in the directory, yank them out of the
                 # RPM itself!
                 simp_doc_rpm = Dir.glob("#{@build_dir}/SIMP/RPMS/*/simp-doc*.rpm").last
-                if not simp_doc_rpm then
-                  raise(Exception,"Error: Could not find simp-doc*.rpm in the build, something went very wrong")
+                unless simp_doc_rpm
+                  raise(StandardError,"Error: Could not find simp-doc*.rpm in the build, something went very wrong")
                 end
 
                 Dir.mktmpdir { |dir|
@@ -141,8 +165,8 @@ module Simp::Rake::Build
                     %x{rpm2cpio #{simp_doc_rpm} | cpio -u --quiet --warning none -ivd ./usr/share/doc/simp-*/pdf/SIMP*.pdf 2>&1 > /dev/null}
                     pdf_docs = Dir.glob("usr/share/doc/simp-*/pdf/*.pdf")
 
-                    if pdf_docs.empty? then
-                      raise(Exception,"Error: Could not find any PDFs in the simp-doc RPM, aborting.")
+                    if pdf_docs.empty?
+                      raise(StandardError,"Error: Could not find any PDFs in the simp-doc RPM, aborting.")
                     end
 
                     pdf_docs.each do |pdf|
@@ -156,13 +180,30 @@ module Simp::Rake::Build
 
           # FIXME: this is a horribad way of sharing with `build:auto`
           $simp_tarballs = {}
-          @target_dists.each do |dist|
-            base_dir = "#{@dvd_dir}/#{dist}/staging"
-            dvd_name = [ 'SIMP', 'DVD', dist, get_simp_version ]
-            dvd_tarball = "#{dvd_name.join('-')}.tar.gz"
+
+          if $tarball_tgt
+            target_dists = ['simp6']
+          else
+            target_dists = @target_dists
+          end
+
+          target_dists.each do |dist|
+            if $tarball_tgt
+              dvd_tarball = File.basename($tarball_tgt)
+              base_dir = "#{@dvd_dir}/staging"
+            else
+              base_dir = "#{@dvd_dir}/#{dist}/staging"
+              dvd_name = [ 'SIMP', 'DVD', dist, get_simp_version ]
+              dvd_tarball = "#{dvd_name.join('-')}.tar.gz"
+            end
+
+            mkdir_p(base_dir)
+
             Dir.chdir(base_dir) do
               sh %{tar --owner 0 --group 0 --exclude-vcs --mode=u=rwX,g=rX,o=rX -cpzf "../#{dvd_tarball}" ./*}
-              mv("../#{dvd_tarball}",@dvd_dir)
+              unless $tarball_tgt
+                mv("../#{dvd_tarball}",@dvd_dir)
+              end
             end
 
             puts "Package DVD: #{@dvd_dir}/#{dvd_tarball}"

data/lib/simp/rake/build/unpack.rb

@@ -10,6 +10,7 @@ module Simp::Rake::Build
 
     def initialize( base_dir )
       init_member_vars( base_dir )
+
       @mock = ENV['mock'] || '/usr/bin/mock'
       define_tasks
     end
@@ -78,9 +79,9 @@ module Simp::Rake::Build
         out_dir = "#{File.expand_path(targetdir)}/#{map['baseos']}#{map['version']}-#{map['arch']}"
 
         # Attempt a merge
-        if File.exist?(out_dir) and merge.to_s.strip == 'false' then
+        if File.exist?(out_dir) and merge.to_s.strip == 'false'
           puts "Directory '#{out_dir}' already exists! Would you like to merge? [Yn]?"
-          if not $stdin.gets.strip.match(/^(y.*|$)/i) then
+          unless $stdin.gets.strip.match(/^(y.*|$)/i)
             puts "Skipping #{iso_path}"
             next
           end
@@ -99,11 +100,11 @@ module Simp::Rake::Build
 
         iso_toc.each do |iso_entry|
           target = "#{out_dir}#{iso_entry}"
-          if not File.exist?(target) then
+          unless File.exist?(target)
             FileUtils.mkdir_p(File.dirname(target))
             system("#{iso_info} -R -x #{iso_entry} -i #{iso_path} > #{target}")
           end
-          if progress then
+          if progress
             progress.increment
           else
             print "#"

data/lib/simp/rake/build/upload.rb

@@ -12,6 +12,7 @@ module Simp::Rake::Build
 
     def initialize( base_dir )
       init_member_vars( base_dir )
+
       @mock = ENV['mock'] || '/usr/bin/mock'
       define_tasks
     end
@@ -19,6 +20,11 @@ module Simp::Rake::Build
     def define_tasks
 
       namespace :upload do
+        task :prep do
+          if $simp6
+            @build_dir = $simp6_build_dir
+          end
+        end
 
         ##############################################################################
         # Helper methods
@@ -56,7 +62,7 @@ module Simp::Rake::Build
               stdin,stdout,stderr = Open3.popen3('git','rev-list',start)
               stderr.read !~ /^fatal:/ and is_commit = true
 
-              if is_commit then
+              if is_commit
                 # Snag the date.
                 start, humanstart = `git log #{start} --pretty=format:"%ct##%cd" --max-count=1`.chomp.split('##')
               else
@@ -78,8 +84,8 @@ module Simp::Rake::Build
                   :is_new => false
                 }
                 pkg_info[file][:alias] = file
-                if file =~ /.spec$/ then
-                  if script_format then
+                if file =~ /.spec$/
+                  if script_format
                     pkg_info[file][:alias] = "#{@build_dir}/RPMS/#{Simp::RPM.new(file).name}*.rpm"
                   else
                     pkg_info[file][:alias] = Simp::RPM.new(file).name
@@ -95,7 +101,7 @@ module Simp::Rake::Build
               commit_head = `git log --before="#{start}" --pretty=format:%H --max-count=1 #{File.basename(file)}`.chomp
 
               # Did we find something different?
-              if commit_head.empty? then
+              if commit_head.empty?
                 pkg_info[file][:is_new] = true
               else
                 pkg_info[file][:is_new] = !system('git','diff','--quiet',commit_head,File.basename(file))
@@ -111,7 +117,7 @@ module Simp::Rake::Build
 
           The package list is created from the given date or git identifier (tag, branch, or hash)
         EOM
-        task :get_modified,[:start,:script_format] do |t,args|
+        task :get_modified,[:start,:script_format] => [:prep] do |t,args|
           args.with_defaults(:script_format => false)
 
           args.start or raise "Error: You must specify a 'start'"

data/lib/simp/rake/helpers/version.rb

@@ -2,5 +2,5 @@ module Simp; end
 module Simp::Rake; end
 
 class Simp::Rake::Helpers
-  VERSION = '3.0.2'
+  VERSION = '3.1.0'
 end

data/lib/simp/rake/pkg.rb

@@ -43,16 +43,20 @@ module Simp::Rake
       @pkg_name            = File.basename(@base_dir)
       @pkg_dir             = File.join(@base_dir, 'dist')
       @pkg_tmp_dir         = File.join(@pkg_dir, 'tmp')
+      @pkg_stash_dir       = File.join(@pkg_tmp_dir, '.stash')
       @exclude_list        = [ File.basename(@pkg_dir) ]
       @clean_list          = []
-      @ignore_changes_list = []
+      @ignore_changes_list = [
+        'Gemfile.lock',
+        'spec/fixtures/modules'
+      ]
       @chroot_name         = unique_name
 
       local_spec = Dir.glob(File.join(@base_dir, 'build', '*.spec'))
       unless local_spec.empty?
         @spec_file = local_spec.first
       else
-        FileUtils.mkdir_p(@pkg_tmp_dir) unless File.directory?(@pkg_tmp_dir)
+        FileUtils.mkdir_p(@pkg_stash_dir) unless File.directory?(@pkg_stash_dir)
 
         @spec_tempfile = File.open(File.join(@pkg_tmp_dir, "#{@pkg_name}.spec"), 'w')
         @spec_tempfile.write(rpm_template(simp_version))
@@ -102,14 +106,32 @@ module Simp::Rake
       define_pkg_rpm
       define_pkg_scrub
       task :default => 'pkg:tar'
+
+      Rake::Task['pkg:tar'].enhance(['pkg:restore_stash'])
+      Rake::Task['pkg:srpm'].enhance(['pkg:restore_stash'])
+      Rake::Task['pkg:rpm'].enhance(['pkg:restore_stash'])
+
       self
     end
 
+    # Add a file to the pkg stash
+    # These will be restored to the @pkg_dir at the end of the run
+    def stash(file)
+      FileUtils.mv(file, @pkg_stash_dir)
+    end
+
+    # Restore everything from the stash dir
+    def restore_stash
+      Dir.glob(File.join(@pkg_stash_dir, '*')).each do |file|
+        FileUtils.mv(file, @pkg_dir)
+      end
+    end
+
     # Initialize the mock space if passed and retrieve the spec info from that
     # space directly.
     #
     # Ensures that the correct file names are used across the board.
-    def initialize_spec_info(chroot, unique)
+    def initialize_spec_info(chroot, unique='false')
       unless @spec_info
         # This gets the resting spec file and allows us to pull out the name
         @spec_info   = Simp::RPM.get_info(@spec_file)
@@ -122,38 +144,40 @@ module Simp::Rake
             @chroot_name = @chroot_name + '__' + Time.now.strftime('%s%L')
           end
 
-          mock_cmd = mock_pre_check( chroot, @chroot_name, unique ) + " --root #{chroot}"
+          if @spec_info[:has_dist_tag]
+            mock_cmd = mock_pre_check( chroot, @chroot_name, unique ) + " --root #{chroot}"
 
-          # Need to do this in case there is already a directory in /tmp
-          rand_dirname = (0...10).map { ('a'..'z').to_a[rand(26)] }.join
-          rand_tmpdir = %(/tmp/#{rand_dirname}_tmp)
+            # Need to do this in case there is already a directory in /tmp
+            rand_dirname = (0...10).map { ('a'..'z').to_a[rand(26)] }.join
+            rand_tmpdir = %(/tmp/#{rand_dirname}_tmp)
 
-          # Hack to work around the fact that we have conflicting '-D' entries
-          # TODO: Refactor this
-          mock_cmd = mock_cmd.split(/-D '.*?'/).join
-          mock_cmd = "#{mock_cmd} -D 'pup_module_info_dir #{rand_tmpdir}'"
+            # Hack to work around the fact that we have conflicting '-D' entries
+            # TODO: Refactor this
+            mock_cmd = mock_cmd.split(/-D '.*?'/).join
+            mock_cmd = "#{mock_cmd} -D 'pup_module_info_dir #{rand_tmpdir}'"
 
-          sh %Q(#{mock_cmd} --chroot 'mkdir -p #{rand_tmpdir}')
+            sh %Q(#{mock_cmd} --chroot 'mkdir -p #{rand_tmpdir}')
 
-          @puppet_module_info_files.each do |copy_in|
-            if File.exist?(copy_in)
-              sh %Q(#{mock_cmd} --copyin #{copy_in} #{rand_tmpdir})
+            @puppet_module_info_files.each do |copy_in|
+              if File.exist?(copy_in)
+                sh %Q(#{mock_cmd} --copyin #{copy_in} #{rand_tmpdir})
+              end
             end
-          end
 
-          sh %Q(#{mock_cmd} --chroot 'chmod -R ugo+rwX #{rand_tmpdir}')
+            sh %Q(#{mock_cmd} --chroot 'chmod -R ugo+rwX #{rand_tmpdir}')
 
-          info_hash = {
-            :command    => %Q(#{mock_cmd} --chroot --cwd='#{rand_tmpdir}'),
-            :rpm_extras => %(--specfile #{rand_tmpdir}/#{File.basename(@spec_file)} )
-          }
+            info_hash = {
+              :command    => %Q(#{mock_cmd} --chroot --cwd='#{rand_tmpdir}'),
+              :rpm_extras => %(--specfile #{rand_tmpdir}/#{File.basename(@spec_file)} )
+            }
 
-          @spec_info = Simp::RPM.get_info(@spec_file, info_hash)
+            @spec_info = Simp::RPM.get_info(@spec_file, info_hash)
+          end
         end
 
         @dir_name       = "#{@spec_info[:name]}-#{@spec_info[:version]}"
-        @mfull_pkg_name = "#{@dir_name}-#{@spec_info[:release]}"
-        @full_pkg_name  = @mfull_pkg_name.gsub("%{?snapshot_release}","")
+        _full_pkg_name = "#{@dir_name}-#{@spec_info[:release]}"
+        @full_pkg_name  = _full_pkg_name.gsub("%{?snapshot_release}","")
         @tar_dest       = "#{@pkg_dir}/#{@full_pkg_name}.tar.gz"
 
         if @tar_dest =~ /UNKNOWN/
@@ -179,11 +203,14 @@ module Simp::Rake
       end
     end
 
-
     def define_pkg_tar
       namespace :pkg do
         directory @pkg_dir
 
+        task :restore_stash do |t,args|
+          at_exit { restore_stash }
+        end
+
         task :initialize_spec_info,[:chroot,:unique] => [@pkg_dir] do |t,args|
           args.with_defaults(:chroot => nil)
           args.with_defaults(:unique => false)
@@ -210,6 +237,13 @@ module Simp::Rake
             @tar_dest = "#{@pkg_dir}/#{@full_pkg_name}#{l_date}.tar.gz"
           end
 
+          # Remove any tar files that are not from this version
+          tar_files = Dir.glob(%(#{@pkg_dir}/#{@spec_info[:name]}-#{@spec_info[:version]}*.tar.gz))
+          tar_files.delete(@tar_dest)
+          tar_files.each do |tf|
+            stash(tf)
+          end
+
           target_dir = File.basename(@base_dir)
 
           Dir.chdir(%(#{@base_dir}/..)) do
@@ -217,12 +251,15 @@ module Simp::Rake
             if File.exist?(@tar_dest)
               Find.find(target_dir) do |path|
                 filename = File.basename(path)
+
                 Find.prune if filename =~ /^\./
                 Find.prune if ((filename == File.basename(@pkg_dir)) && File.directory?(path))
-                Find.prune if ((filename == 'spec') && File.directory?(path))
-                Find.prune if @ignore_changes_list.include?(path)
+
+                to_ignore = @ignore_changes_list.map{|x| x = Dir.glob(File.join(@base_dir, x))}.flatten
+                Find.prune if to_ignore.include?(File.expand_path(path))
 
                 next if File.directory?(path)
+
                 unless uptodate?(@tar_dest,[path])
                   require_rebuild = true
                   break
@@ -265,12 +302,28 @@ module Simp::Rake
             @tar_dest = "#{@pkg_dir}/#{@full_pkg_name}#{l_date}.tar.gz"
           end
 
-          mock_cmd = mock_pre_check( args[:chroot], @chroot_name, args[:unique] )
+          srpms = Dir.glob(%(#{@pkg_dir}/#{@spec_info[:name]}*-#{@spec_info[:version]}-*#{l_date}*.src.rpm))
+
+          # Get rid of any SRPMs that are not of this distribution build if we
+          # have found one
+          if @spec_info[:dist_tag]
+            srpms.delete_if do |srpm|
+              if srpm.split(@spec_info[:dist_tag]).last != '.src.rpm'
+                if File.exist?(srpm)
+                  stash(srpm)
+                end
 
-          srpms = Dir.glob(%(#{@pkg_dir}/#{@spec_info[:name]}-#{@spec_info[:version]}-#{@spec_info[:release]}#{l_date}.*src.rpm))
+                true
+              else
+                false
+              end
+            end
+          end
 
           if require_rebuild?(srpms, @tar_dest)
 
+            mock_cmd = mock_pre_check( args[:chroot], @chroot_name, args[:unique] )
+
             @puppet_module_info_files.each do |file|
               next unless File.exist?(file)
 
@@ -278,7 +331,7 @@ module Simp::Rake
                 next if File.directory?(path)
 
                 tgt_file = File.join(@pkg_dir, File.basename(path))
-                FileUtils.rm_rf(tgt_file) if File.exist?(tgt_file)
+                FileUtils.remove_entry_secure(tgt_file) if File.exist?(tgt_file)
                 FileUtils.cp(path, @pkg_dir) if File.exist?(path)
               end
             end
@@ -316,27 +369,46 @@ module Simp::Rake
             @tar_dest = "#{@pkg_dir}/#{@full_pkg_name}#{l_date}.tar.gz"
           end
 
-          mock_cmd = mock_pre_check(args[:chroot], @chroot_name, args[:unique])
+          rpms = Dir.glob(%(#{@pkg_dir}/#{@spec_info[:name]}-*#{@spec_info[:version]}-*#{l_date}*.rpm))
 
-          rpms = Dir.glob(%(#{@pkg_dir}/#{@spec_info[:name]}-#{@spec_info[:version]}-#{@spec_info[:release]}#{l_date}.*rpm))
           srpms = rpms.select{|x| x =~ /src\.rpm$/}
           rpms = (rpms - srpms)
 
+          # Get rid of any RPMs that are not of this distribution build if we
+          # have found one
+          if @spec_info[:dist_tag]
+            rpms.delete_if do |rpm|
+              if rpm.split(@spec_info[:dist_tag]).last != ".#{@spec_info[:arch]}.rpm"
+                if File.exist?(rpm)
+                  stash(rpm)
+                end
+
+                true
+              else
+                false
+              end
+            end
+          end
+
           srpms.each do |srpm|
             dirname = File.dirname(srpm)
             basename = File.basename(srpm,'.src.rpm')
-            rpm = File.join(dirname, basename, 'rpm')
+            srpm_info = Simp::RPM.get_info(srpm)
+
+            rpm = [File.join(dirname, basename), srpm_info[:arch], 'rpm'].join('.')
             if require_rebuild?(rpm, srpm)
+              mock_cmd = mock_pre_check(args[:chroot], @chroot_name, args[:unique])
+
               cmd = %Q(#{mock_cmd} --root #{args[:chroot]} #{mocksnap} #{srpm})
 
               sh cmd
-            end
-          end
 
-          # remote chroot unless told not to (saves LOTS of space during ISO builds)
-          unless ENV['SIMP_RAKE_MOCK_cleanup'] == 'no'
-            cmd = %Q(#{mock_cmd} --root #{args[:chroot]} --clean)
-            sh cmd
+              # remote chroot unless told not to (saves LOTS of space during ISO builds)
+              unless ENV['SIMP_RAKE_MOCK_cleanup'] == 'no'
+                cmd = %Q(#{mock_cmd} --root #{args[:chroot]} --clean)
+                sh cmd
+              end
+            end
           end
         end
       end
@@ -350,7 +422,7 @@ module Simp::Rake
         Scrub the #{@pkg_name} mock build directory.
         EOM
         task :scrub,[:chroot,:unique] do |t,args|
-          args.with_defaults(:unique => false)
+          args.with_defaults(:unique => 'false')
 
           mock_cmd = mock_pre_check( args[:chroot], @chroot_name, args[:unique], false )
           cmd = %Q(#{mock_cmd} --scrub=all)
@@ -371,23 +443,19 @@ module Simp::Rake
 
     # Return True if any of the 'old' Array are newer than the 'new' Array
     def require_rebuild?(new, old)
-      require_rebuild = false
-      require_rebuild = true if ( Array(old).empty? || Array(new).empty?)
-      unless require_rebuild
-        Array(new).each do |new_file|
-          unless File.exist?(new_file)
-            require_rebuild = true
-            break
-          end
+      return true if ( Array(old).empty? || Array(new).empty?)
 
-          unless uptodate?(new_file, Array(old))
-            require_rebuild = true
-            break
-          end
+      Array(new).each do |new_file|
+        unless File.exist?(new_file)
+          return true
+        end
+
+        unless uptodate?(new_file, Array(old))
+          return true
         end
       end
 
-      return require_rebuild
+      return false
     end
 
     # Run some pre-checks to make sure that mock will work properly.
@@ -397,23 +465,26 @@ module Simp::Rake
     # Pass init=false if you do not want the function to initialize.
     #
     # Returns a String that contains the appropriate mock command.
-    def mock_pre_check( chroot, unique_ext, unique=false, init=true )
+    def mock_pre_check( chroot, unique_ext, unique='false', init=true )
 
       mock = ENV['mock'] || '/usr/bin/mock'
 
-      raise(Exception,"Could not find mock on your system, exiting") unless File.executable?(mock)
+      raise(StandardError,"Could not find mock on your system, exiting") unless File.executable?(mock)
 
       mock_configs = Pkg.get_mock_configs
       unless chroot
-        raise(Exception,
+        raise(StandardError,
           "Error: No mock chroot provided. Your choices are:\n  #{mock_configs.join("\n  ")}"
         )
       end
 
-      unless mock_configs.include?(chroot)
-        raise(Exception,
-          "Error: Invalid mock chroot provided. Your choices are:\n  #{mock_configs.join("\n  ")}"
-        )
+      # If you pass a config file, just take it
+      unless chroot.split('.').last == 'cfg'
+        unless mock_configs.include?(chroot)
+          raise(StandardError,
+            "Error: Invalid mock chroot provided. Your choices are:\n  #{mock_configs.join("\n  ")}"
+          )
+        end
       end
 
       raise %Q(unique_ext must be a String ("#{unique_ext}" = #{unique_ext.class})) unless unique_ext.is_a?(String)
@@ -453,8 +524,12 @@ module Simp::Rake
     end
 
     def is_mock_initialized( mock_cmd, chroot )
+      @@initialized_mocks ||= []
+      return true if @@initialized_mocks.include?(chroot)
+
       %x{#{mock_cmd} --root #{chroot} --chroot "test -d /tmp" &> /dev/null }
       initialized = $?.success?
+      @@initialized_mocks << chroot
 
       # A simple test to see if the chroot is initialized.
       initialized

data/lib/simp/rpm.rb

@@ -88,8 +88,11 @@ module Simp
     #                  reference to the spec file itself
     # }
     def self.get_info(rpm_source, mock_hash=nil)
-      info    = Hash.new
-      rpm_cmd = "rpm -q --queryformat '%{NAME} %{VERSION} %{RELEASE}\n'"
+      info = {
+        :has_dist_tag => false
+      }
+
+      rpm_cmd = "rpm -q --queryformat '%{NAME} %{VERSION} %{RELEASE} %{ARCH}\n'"
 
       if mock_hash
         # Suppression of error messages is a hack for the following
@@ -105,10 +108,20 @@ module Simp
       end
 
       if File.readable?(rpm_source)
+        if File.read(rpm_source).include?('%{?dist}')
+          info[:has_dist_tag] = true
+        end
+
         if rpm_source.split('.').last == 'rpm'
           results = execute("#{rpm_cmd} -p #{rpm_source}")
         elsif mock_hash
           results = execute("#{rpm_cmd}")
+
+          if info[:has_dist_tag]
+            info[:dist_tag] = execute(%(#{mock_hash[:command]} --chroot 'rpm --eval "%{dist}"' 2>/dev/null))[:stdout].strip
+
+            info[:dist_tag] = nil if (info[:dist_tag][0].chr == '%')
+          end
         else
           results = execute("#{rpm_cmd} --specfile #{rpm_source}")
         end
@@ -121,7 +134,7 @@ module Simp
 EOE
         end
 
-        info[:name],info[:version],info[:release] = results[:stdout].strip.split("\n").first.split(' ')
+        info[:name], info[:version], info[:release], info[:arch] = results[:stdout].strip.split("\n").first.split(' ')
       else
         raise "Error: unable to read '#{rpm_source}'"
       end