simp-rake-helpers 1.0.15 → 1.1.0

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

@@ -0,0 +1,287 @@
+require 'simp/rake'
+require 'simp/rake/build/constants'
+
+module Simp; end
+module Simp::Rake; end
+module Simp::Rake::Build
+
+  class Iso < ::Rake::TaskLib
+    include Simp::Rake
+    include Simp::Rake::Build::Constants
+
+    def initialize( base_dir )
+      init_member_vars( base_dir )
+      @mock = ENV['mock'] || '/usr/bin/mock'
+      define_tasks
+    end
+
+    def define_tasks
+
+      File.umask(0007)
+
+      namespace :iso do
+
+        # Remove packages from the given directory. The goal of this method is to help
+        # get the distro to be as small as possible.
+        # [:from_dir] Root directory to remove packages from (removes recursively)
+        # [:exclude_dirs] Array of directories to not remove any packages from
+        # [:exclude_pkgs] Array of packages to not remove
+        def prune_packages(from_dir,exclude_dirs,exclude_pkgs,mkrepo='createrepo -p',use_hack=true)
+          $stderr.puts "Starting to prune..."
+          Dir.chdir(from_dir) do
+            prune_count = 0
+
+            Find.find('.') do |path|
+              Find.prune if exclude_dirs.include?(File.basename(path))
+
+              if File.basename(path) =~ /.*\.rpm/
+                # Get the package name from the RPM.
+                # Note: an alternative method may be to just simply check the names
+                # of the RPMs themselves instead of the names of the packages.
+                pkg = nil
+                if use_hack
+                  # The proper way (defined below) is way too slow, so this hack helps
+                  # speed up the process by reading the file directly. If the code is
+                  # not working, attempt this without using the hack, just be ready
+                  # to wait a long time for the code to complete.
+                  pkgname = File.basename(path).split('-').first
+                  File.open(path,'r').each_line do |line|
+                    if encode_line(line) =~ /C\000(\S+\000)?(#{Regexp.escape(pkgname)}\S*)\000/
+                      pkg = $2.split(/\000/).first
+                      break
+                    end
+                  end
+                else
+                  # Proper way to obtain the RPM's package name, but WAY too slow
+                  pkg = %x{rpm -qp --qf "%{NAME}" #{path} 2>/dev/null}.chomp
+                end
+
+                unless exclude_pkgs.include?(pkg)
+                  rm(path)
+                  prune_count += 1
+                end
+              end
+            end
+            $stderr.puts "Info: Pruned #{prune_count} packages from #{from_dir}"
+
+            if prune_count > 0
+              # Recreate the now-pruned repos
+              basepath = '.'
+              if (File.basename(from_dir) =~ /^RHEL/)
+                # This covers old versions of RHEL that don't follow the new
+                # way of doing things.
+                unless Dir.glob("Server/*.rpm").empty?
+                  basepath = 'Server'
+                end
+              end
+
+              Dir.chdir(basepath) do
+                cp(Dir.glob("repodata/*comps*.xml").first,"simp_comps.xml")
+                sh %{#{mkrepo} -g simp_comps.xml .}
+                rm("simp_comps.xml")
+              end
+            end
+          end
+        end # End of prune_packages
+
+        desc <<-EOM
+      Build the SIMP ISO(s).
+       * :tarball - Path of the source tarball or directory containing the source
+           tarballs.
+       * :unpacked_dvds - Path of the directory containing the unpacked base OS
+           directories. Default is the current directory.
+       * :prune - Flag for whether unwanted packages should be pruned prior to
+           building the ISO. Default is true.
+           EOM
+        task :build,[:tarball,:unpacked_dvds,:prune] do |t,args|
+          args.with_defaults(:unpacked_dvds => "#{@run_dir}", :prune => 'true')
+
+          if args.tarball.nil?
+            fail("Error: You must specify a source tarball or tarball directory!")
+          else
+            tarball = File.expand_path(args.tarball)
+            unless File.exist?(tarball)
+              fail("Error: Could not find tarball at '#{tarball}'!")
+            end
+          end
+
+          tarfiles = File.directory?(tarball) ?
+            Dir.glob("#{tarball}/*.tar.gz") : [tarball]
+          vermap = YAML::load_file("#{@base_dir}/rakefiles/vermap.yaml")
+
+          tarfiles.each do |tarball|
+            namepieces = File.basename(tarball,".tar.gz").split('-')
+            simpver = namepieces[3..-1].join('-')
+            baseos = namepieces[2]
+
+            iso_dirs = Dir.glob("#{File.expand_path(args.unpacked_dvds)}/#{baseos}*")
+            if iso_dirs.empty?
+              fail("Error: No unpacked DVD directories found for '#{baseos}' under '#{File.expand_path(args.unpacked_dvds)}'")
+            end
+
+            # Process each unpacked base OS ISO directory found
+            iso_dirs.each do |dir|
+              baseosver = '???'
+              arch      = '???'
+
+              # read the .treeinfo file (INI format)
+              # ------------------------------------
+              require 'puppet'
+              require 'puppet/util/inifile'
+
+              file = "#{dir}/.treeinfo"
+              fail("ERROR: no file '#{file}'") unless File.file?(file)
+
+              ini = Puppet::Util::IniConfig::PhysicalFile.new(file)
+              ini.read
+              sections = ini.sections.map{ |s| s.name }
+
+              # NOTE: RHEL7 discs claim [general] section is deprecated.
+              if sections.include?('general')
+                h = Hash[ ini.get_section('general').entries ]
+                arch      = h.fetch('arch', arch).strip
+                baseosver = h.fetch('version', baseosver).strip
+                baseosver += '.0' if (baseosver.count('.') < 1)
+              end
+              # ------------------------------------
+
+              # Skip if SIMP version doesn't match target base OS version
+              next unless vermap[simpver.split('.').first].eql?(baseosver.split('.').first)
+
+              mkrepo = baseosver.split('.').first == '5' ? 'createrepo -s sha -p' : 'createrepo -p'
+
+              @simp_dvd_dirs.each do |clean_dir|
+                if File.directory?("#{dir}/#{clean_dir}")
+                  rm_rf("#{dir}/#{clean_dir}")
+                elsif File.file?("#{dir}/#{clean_dir}")
+                  fail("Error: #{dir}/#{clean_dir} is a file, expecting directory!")
+                end
+              end
+
+              # Prune unwanted packages
+              begin
+                system("tar --no-same-permissions -C #{dir} -xzf #{tarball} *simp_pkglist.txt")
+              rescue
+                # Does not matter if the command fails
+              end
+              pkglist_file = ENV.fetch(
+                                       'SIMP_PKGLIST_FILE',
+                                        File.join(dir,"#{baseosver.split('.').first}-simp_pkglist.txt")
+                                      )
+              puts
+              puts '-'*80
+              puts "### Pruning packages not in file '#{pkglist_file}'"
+              puts
+              puts '   (override this with `SIMP_PKGLIST_FILE=<file>`)'
+              puts
+              puts '-'*80
+              puts
+
+              if (args.prune.casecmp("false") != 0) && File.exist?(pkglist_file)
+                exclude_pkgs = Array.new
+                File.read(pkglist_file).each_line do |line|
+                  next if line =~ /^(\s+|#.*)$/
+                  exclude_pkgs.push(line.chomp)
+                end
+                prune_packages(dir,['SIMP'],exclude_pkgs,mkrepo)
+              end
+
+              # Add the SIMP code
+              system("tar --no-same-permissions -C #{dir} -xzf #{tarball}")
+
+              Dir.chdir("#{dir}/SIMP") do
+                # Add the SIMP Dependencies
+                simp_base_ver = simpver.split('-').first
+                simp_dep_src = %(SIMP#{simp_base_ver}_#{baseos}#{baseosver}_#{arch})
+                yum_dep_location = File.join(@build_dir,'yum_data',simp_dep_src,'packages')
+
+                unless File.directory?(yum_dep_location)
+                  fail("Could not find dependency directory at #{yum_dep_location}")
+                end
+
+                yum_dep_rpms = Dir.glob(File.join(yum_dep_location,'*.rpm'))
+                if yum_dep_rpms.empty?
+                  fail("Could not find any dependency RPMs at #{yum_dep_location}")
+                end
+
+                # Add any one-off RPMs that you might want to add to your own build
+                # These are *not* checked to make sure that they actually match your
+                # environment
+                aux_packages = File.join(@build_dir,'yum_data',simp_dep_src,'aux_packages')
+                if File.directory?(aux_packages)
+                  yum_dep_rpms += Dir.glob(File.join(aux_packages,'*.rpm'))
+                end
+
+                yum_dep_rpms.each do |rpm|
+                  rpm_arch = rpm.split('.')[-2]
+
+                  unless File.directory?(rpm_arch)
+                    mkdir(rpm_arch)
+                  end
+
+                  # Just in case this is a symlink, broken, or some other nonsense.
+                  target_file = File.join(rpm_arch,File.basename(rpm))
+                  rm_f(target_file) if File.exist?(target_file)
+
+                  cp(rpm,rpm_arch)
+                end
+
+                fail("Could not find architecture '#{arch}' in the SIMP distribution") unless File.directory?(arch)
+                # Get everything set up properly...
+                Dir.chdir(arch) do
+                  Dir.glob('../*') do |rpm_dir|
+                    # Don't dive into ourselves
+                    next if File.basename(rpm_dir) == arch
+
+                    Dir.glob(%(#{rpm_dir}/*.rpm)) do |source_rpm|
+                      link_target = File.basename(source_rpm)
+                      if File.exist?(source_rpm) && File.exist?(link_target)
+                        next if Pathname.new(source_rpm).realpath == Pathname.new(link_target).realpath
+                      end
+
+                      ln_sf(source_rpm,link_target)
+                    end
+                  end
+
+                  fail("Error: Could not run createrepo in #{Dir.pwd}") unless system(%(#{mkrepo} .))
+                end
+              end
+
+              # Make sure we have all of the necessary RPMs!
+              Rake::Task['pkg:repoclosure'].invoke(File.expand_path(dir))
+
+              # Do some sane chmod'ing and build ISO
+              system("chmod -fR u+rwX,g+rX,o=g #{dir}")
+              @simp_output_iso = "SIMP-#{simpver}-#{baseos}-#{baseosver}-#{arch}.iso"
+              system("mkisofs -uid 0 -gid 0 -o #{@simp_output_iso} -b isolinux/isolinux.bin -c boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -r -m TRANS.TBL #{dir}")
+            end
+          end # End of tarfiles loop
+        end
+
+        desc <<-EOM
+        Build the source ISO.
+          Note: The process clobbers the temporary and built files, rebuilds the
+          tarball(s) and packages the source ISO. Therefore it will take a
+          while.
+            * :key - The GPG key to sign the RPMs with. Defaults to 'prod'.
+            * :chroot - An optional Mock Chroot. If this is passed, the tar:build task will be called.
+        EOM
+        task :src,[:key,:chroot] do |t,args|
+          args.with_defaults(:key => 'prod')
+
+          if Dir.glob("#{@dvd_dir}/*.gz").empty? && !args.chroot
+            fail("Error: Could not find compiled source tarballs, please pass a chroot.")
+          end
+
+          Rake::Task['tar:build'].invoke(args.chroot) if args.chroot
+
+          Dir.chdir(@base_dir) do
+            File.basename(Dir.glob("#{@dvd_dir}/*.tar.gz").first,'.tar.gz') =~ /SIMP-DVD-[^-]+-(.+)/
+            name = "SIMP-#{$1}"
+            sh %{mkisofs -uid 0 -gid 0 -D -A #{name} -J -joliet-long -m ".git*" -m "./build/tmp" -m "./build/SRPMS" -m "./build/RPMS" -m "./build/build_keys" -o #{name}.src.iso .}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,731 @@
+#!/usr/bin/rake -T
+
+require 'simp/rake/build/constants'
+
+module Simp; end
+module Simp::Rake; end
+module Simp::Rake::Build
+
+  class Pkg < ::Rake::TaskLib
+    include Simp::Rake::Build::Constants
+
+    def initialize( base_dir )
+      init_member_vars( base_dir )
+      @mock = ENV['mock'] || '/usr/bin/mock'
+      define_tasks
+    end
+
+    def define_tasks
+      task :help do
+        puts <<-EOF.gsub(/^  /, '')
+          SIMP_RAKE_CHOWN_EVERYTHING=(Y|N)
+              If 'Y', builds are preceded by a massive chown -R mock on the entire source tree
+
+          EOF
+      end
+
+      namespace :pkg do
+
+        ##############################################################################
+        # Main tasks
+        ##############################################################################
+
+        # Have to get things set up inside the proper namespace
+        task :prep do
+          @build_dirs = {
+            :modules => get_module_dirs,
+            :aux => [
+              "#{@build_dir}/GPGKEYS",
+              "#{@src_dir}/puppet/bootstrap",
+              "#{@src_dir}/rsync",
+              "#{@src_dir}/utils"
+            ],
+            :doc => "#{@src_dir}/doc",
+            :simp_cli => "#{@src_dir}/rubygems/simp-cli",
+            :simp => "#{@src_dir}",
+          }
+
+          @pkg_dirs = {
+            :simp => "#{@build_dir}/SIMP",
+            :ext  => "#{@build_dir}/Ext_*"
+          }
+        end
+
+        task :mock_prep do
+          chown_everything = ENV.fetch( 'SIMP_RAKE_CHOWN_EVERYTHING', 'Y' ).chomp.index( %r{^(1|Y|true|yes)$}i ) || false
+
+          verbose(true) do
+            next if not chown_everything
+            # Set the permissions properly for mock to dig through your source
+            # directories.
+            chown_R(nil,'mock',@base_dir)
+            # Ruby >= 1.9.3 chmod_R('g+rXs',@base_dir)
+            Find.find(@base_dir) do |path|
+              if File.directory?(path)
+                %x{chmod g+rXs #{Shellwords.escape(path)}}
+              end
+            end
+          end
+        end
+
+        task :clean,[:chroot] => [:prep] do |t,args|
+          validate_in_mock_group?
+          @build_dirs.each_pair do |k,dirs|
+            Parallel.map(
+              Array(dirs),
+              :in_processes => get_cpu_limit,
+              :progress => t.name
+            ) do |dir|
+              Dir.chdir(dir) do
+                begin
+                  sh %{rake clean[#{args.chroot}]}
+                rescue Exception => e
+                  raise Parallel::Kill
+                end
+
+              end
+            end
+          end
+
+          # FIXME: not thread-safe
+          %x{mock -r #{args.chroot} --scrub=all} if args.chroot
+        end
+
+        task :clobber,[:chroot] => [:prep] do |t,args|
+          validate_in_mock_group?
+          @build_dirs.each_pair do |k,dirs|
+            Parallel.map(
+              Array(dirs),
+              :in_processes => get_cpu_limit,
+              :progress => t.name
+            ) do |dir|
+              Dir.chdir(dir) do
+                sh %{rake clobber[#{args.chroot}]}
+              end
+            end
+          end
+        end
+
+        desc <<-EOM
+          Prepare the GPG key space for a SIMP build.
+
+          If passed anything but 'dev', will fail if the directory is not present in
+          the 'build/build_keys' directory.
+        EOM
+        task :key_prep,[:key] do |t,args|
+          require 'securerandom'
+
+          args.with_defaults(:key => 'dev')
+
+          Dir.chdir("#{@build_dir}/build_keys") {
+            if (args.key != 'dev')
+              fail("Could not find GPG keydir '#{args.key}' in '#{Dir.pwd}'") unless File.directory?(args.key)
+            end
+
+            mkdir('dev') unless File.directory?('dev')
+            chmod(0700,'dev')
+
+            Dir.chdir('dev') {
+              dev_email = 'gatekeeper@simp.development.key'
+              current_key = `gpg --homedir=#{Dir.pwd} --list-keys #{dev_email} 2>/dev/null`
+              days_left = 0
+              if !current_key.empty?
+                lasts_until = current_key.lines.first.strip.split("\s").last.delete(']')
+                days_left = (Date.parse(lasts_until) - DateTime.now).to_i
+              end
+
+              if days_left > 0
+                puts "GPG key will expire in #{days_left} days."
+              else
+                puts "Generating new GPG key"
+
+                Dir.glob('*').each do |todel|
+                  rm_rf(todel)
+                end
+
+                expire_date = (DateTime.now + 14)
+                now = Time.now.to_i.to_s
+                dev_email = 'gatekeeper@simp.development.key'
+                passphrase = SecureRandom.base64(500)
+
+                gpg_infile = <<-EOM
+      %echo Generating Development GPG Key
+      %echo
+      %echo This key will expire on #{expire_date}
+      %echo
+      Key-Type: RSA
+      Key-Length: 4096
+      Key-Usage: sign
+      Name-Real: SIMP Development
+      Name-Comment: Development key #{now}
+      Name-Email: #{dev_email}
+      Expire-Date: 2w
+      Passphrase: #{passphrase}
+      %pubring pubring.gpg
+      %secring secring.gpg
+      # The following creates the key, so we can print "Done!" afterwards
+      %commit
+      %echo New GPG Development Key Created
+                EOM
+
+                gpg_agent_script = <<-EOM
+      #!/bin/sh
+
+      gpg-agent --homedir=#{Dir.pwd} --batch --daemon --pinentry-program /usr/bin/pinentry-curses < /dev/null &
+                EOM
+
+                File.open('gengpgkey','w'){ |fh| fh.puts(gpg_infile) }
+                File.open('run_gpg_agent','w'){ |fh| fh.puts(gpg_agent_script) }
+                chmod(0755,'run_gpg_agent')
+
+                gpg_agent_pid = nil
+                gpg_agent_socket = nil
+
+                if File.exist?(%(#{ENV['HOME']}/.gnupg/S.gpg-agent))
+                  gpg_agent_socket = %(#{ENV['HOME']}/.gnupg/S.gpg-agent)
+                  gpg_agent_socket = %(#{ENV['HOME']}/.gnupg/S.gpg-agent)
+                end
+
+                begin
+                  unless gpg_agent_socket
+                    gpg_agent_output = %x(./run_gpg_agent).strip
+
+                    if gpg_agent_output.empty?
+                      # This is a working version of gpg-agent, that means we need to
+                      # connect to it to figure out what's going on
+
+                      gpg_agent_socket = %x(#{Dir.pwd}/S.gpg-agent)
+                      gpg_agent_pid_info = %x(gpg-agent --homedir=#{Dir.pwd} /get serverpid).strip
+                      gpg_agent_pid_info =~ %r(\[(\d+)\])
+                      gpg_agent_pid = $1
+                    else
+                      # Are we running a broken version of the gpg-agent? If so, we'll
+                      # get back info on the command line.
+
+                      gpg_agent_info = gpg_agent_output.split(';').first.split('=').last.split(':')
+                      gpg_agent_socket = gpg_agent_info[0]
+                      gpg_agent_pid = gpg_agent_info[1].strip.to_i
+
+                      if not File.exist? (%(#{Dir.pwd}/#{File.basename(gpg_agent_socket)})) then
+                        ln_s(gpg_agent_socket,%(#{Dir.pwd}/#{File.basename(gpg_agent_socket)}))
+                      end
+                    end
+                  end
+
+                  sh %{gpg --homedir=#{Dir.pwd} --batch --gen-key gengpgkey}
+                  sh %{gpg --homedir=#{Dir.pwd} --armor --export #{dev_email} > RPM-GPG-KEY-SIMP-Dev}
+                ensure
+                  begin
+                    rm('S.gpg-agent') if File.symlink?('S.gpg-agent')
+
+                    if gpg_agent_pid
+                      Process.kill(0,gpg_agent_pid)
+                      Process.kill(15,gpg_agent_pid)
+                    end
+                    rescue Errno::ESRCH
+                    # Not Running, Nothing to do!
+                  end
+                end
+              end
+            }
+
+            Dir.chdir(args.key) {
+              rpm_build_keys = Dir.glob('RPM-GPG-KEY-*')
+              target_dir = '../../GPGKEYS'
+
+              fail("Could not find any RPM-GPG-KEY files in '#{Dir.pwd}'") if rpm_build_keys.empty?
+              fail("No GPGKEYS directory at '#{Dir.pwd}/#{target_dir}") unless File.directory?(target_dir)
+
+              dkfh = File.open("#{target_dir}/.dropped_keys",'w')
+
+              rpm_build_keys.each do |gpgkey|
+                cp(gpgkey,target_dir)
+                dkfh.puts(gpgkey)
+              end
+
+              dkfh.flush
+              dkfh.close
+            }
+          }
+        end
+
+        desc <<-EOM
+          Build the entire SIMP release.
+
+            Building this environment requires a working Mock setup (http://fedoraproject.org/wiki/Projects/Mock)
+            * :chroot - The Mock chroot configuration to use. See the '--root' option in mock(1).
+            * :docs - Build the docs. Set this to false if you wish to skip building the docs.
+            * :key - The GPG key to sign the RPMs with. Defaults to 'dev'.
+        EOM
+        task :build,[:chroot,:docs,:key,:snapshot_release] => [:prep,:mock_prep,:key_prep] do |t,args|
+          validate_in_mock_group?
+
+          args.with_defaults(:key => 'dev')
+          args.with_defaults(:docs => true)
+
+          output_dir = @pkg_dirs[:simp]
+
+          check_dvd_env
+
+          Rake::Task['pkg:modules'].invoke(args.chroot)
+          Rake::Task['pkg:aux'].invoke(args.chroot)
+          if "#{args.docs}" == 'true'
+            Rake::Task['pkg:doc'].invoke(args.chroot)
+          end
+          Rake::Task['pkg:simp_cli'].invoke(args.chroot)
+
+          # The main SIMP RPM must be built last!
+          Rake::Task['pkg:simp'].invoke(args.chroot,args.snapshot_release)
+
+          # Prepare for the build!
+          rm_rf(output_dir)
+
+          # Copy all the resulting files into the target output directory
+          mkdir_p(output_dir)
+
+          @build_dirs.each_pair do |k,dirs|
+            Array(dirs).each do |dir|
+              rpms = Dir.glob("#{dir}/dist/*.rpm")
+              srpms = []
+              rpms.delete_if{|x|
+                del = false
+                if x =~ /\.src\.rpm$/
+                  del = true
+                  srpms << x
+                end
+
+                del
+              }
+
+              srpms.each do |srpm|
+                out_dir = "#{output_dir}/SRPMS"
+                mkdir_p(out_dir) unless File.directory?(out_dir)
+
+                if not uptodate?("#{out_dir}/#{File.basename(srpm)}",[srpm])
+                  cp(srpm,out_dir)
+                end
+              end
+
+              rpms.each do |rpm|
+                out_dir = "#{output_dir}/RPMS/#{rpm.split('.')[-2]}"
+                mkdir_p(out_dir) unless File.directory?(out_dir)
+
+                if not uptodate?("#{out_dir}/#{File.basename(rpm)}",[rpm])
+                  cp(rpm,out_dir)
+                end
+              end
+            end
+          end
+
+          Rake::Task['pkg:signrpms'].invoke(args.key)
+        end
+
+        desc <<-EOM
+          Build the Puppet module RPMs.
+
+            This also builds the simp-mit RPM due to its location.
+            Building this environment requires a working Mock setup (http://fedoraproject.org/wiki/Projects/Mock)
+            * :chroot - The Mock chroot configuration to use. See the '--root' option in mock(1).
+        EOM
+        task :modules,[:chroot] => [:prep,:mock_prep] do |t,args|
+          build(args.chroot,@build_dirs[:modules],t)
+        end
+
+        desc <<-EOM
+          Build simp config rubygem RPM.
+        EOM
+        task :simp_cli,[:chroot] => [:prep,:mock_prep] do |t,args|
+          build(args.chroot,@build_dirs[:simp_cli],t)
+        end
+
+        desc <<-EOM
+          Build the SIMP non-module RPMs.
+
+            Building this environment requires a working Mock setup (http://fedoraproject.org/wiki/Projects/Mock)
+            * :chroot - The Mock chroot configuration to use. See the '--root' option in mock(1).
+        EOM
+        task :aux,[:chroot] => [:prep,:mock_prep]  do |t,args|
+          build(args.chroot,@build_dirs[:aux],t)
+        end
+
+        desc <<-EOM
+          Build the SIMP documentation.
+
+            Building this environment requires a working Mock setup (http://fedoraproject.org/wiki/Projects/Mock)
+            * :chroot - The Mock chroot configuration to use. See the '--root' option in mock(1).
+        EOM
+        task :doc,[:chroot] => [:prep,:mock_prep] do |t,args|
+          build(args.chroot,@build_dirs[:doc],t)
+        end
+
+        desc <<-EOM
+          Build the main SIMP RPM.
+
+            Building this environment requires a working Mock setup (http://fedoraproject.org/wiki/Projects/Mock)
+            * :chroot - The Mock chroot configuration to use. See the '--root' option in mock(1).
+            * :snapshot_release - Will add a define to the Mock to set snapshot_release to current date and time.
+        EOM
+        task :simp,[:chroot,:snapshot_release] => [:prep,:mock_prep] do |t,args|
+          build(args.chroot,@build_dirs[:simp],t,false,args.snapshot_release)
+        end
+
+        desc "Sign the RPMs."
+        task :signrpms,[:key,:rpm_dir,:force] => [:prep,:key_prep,:mock_prep] do |t,args|
+          args.with_defaults(:key => 'dev')
+          args.with_defaults(:rpm_dir => "#{@build_dir}/SIMP/*RPMS")
+          args.with_default(:force => false)
+
+          force = (args.force.to_s == 'false' ? false : true)
+
+          rpm_dirs = Dir.glob(args.rpm_dir)
+          to_sign = []
+
+          rpm_dirs.each do |rpm_dir|
+            Find.find(rpm_dir) do |rpm|
+              next unless File.readable?(rpm)
+              to_sign << rpm if rpm =~ /\.rpm$/
+            end
+          end
+
+          Parallel.map(
+            to_sign,
+            :in_processes => get_cpu_limit,
+            :progress => t.name
+          ) do |rpm|
+            rpminfo = %x{rpm -qip #{rpm} 2>/dev/null}.split("\n")
+            if (force || !rpminfo.grep(/Signature\s+:\s+\(none\)/).empty?)
+              Simp::RPM.signrpm(rpm,"#{@build_dir}/build_keys/#{args.key}")
+            end
+          end
+        end
+
+        desc <<-EOM
+          Check that RPMs are signed.
+
+            Checks all RPM files in a directory to see if they are trusted.
+              * :rpm_dir - A directory containing RPM files to check. Default #{@build_dir}/SIMP
+              * :key_dir - The path to the GPG keys you want to check the packages against. Default #{@build_dir}/GPGKEYS
+        EOM
+        task :checksig,[:rpm_dir,:key_dir] => [:prep] do |t,args|
+          begin
+            args.with_defaults(:rpm_dir => @pkg_dirs[:ext])
+            args.with_defaults(:key_dir => "#{@build_dir}/GPGKEYS")
+
+            rpm_dirs = Dir.glob(args.rpm_dir)
+
+            fail("Could not find files at #{args.rpm_dir}!") if rpm_dirs.empty?
+
+            temp_gpg_dir = Dir.mktmpdir
+
+            rpm_cmd = %{rpm --dbpath #{temp_gpg_dir}}
+
+            sh %{#{rpm_cmd} --initdb}
+
+            # Only import thngs that look like GPG keys...
+            Dir.glob("#{args.key_dir}/*").each do |key|
+              next if File.directory?(key) or not File.readable?(key)
+
+              File.read(key).each_line do |line|
+                if line =~ /-----BEGIN PGP PUBLIC KEY BLOCK-----/
+                  sh %{#{rpm_cmd} --import #{key}}
+                  break
+                end
+              end
+            end
+
+            bad_rpms = []
+            rpm_dirs.each do |rpm_dir|
+              Find.find(rpm_dir) do |path|
+                if (path =~ /.*\.rpm$/)
+                  result = %x{#{rpm_cmd} --checksig #{path}}.strip
+                  if result !~ /:.*\(\S+\).* OK$/
+                    bad_rpms << path.split(/\s/).first
+                  end
+                end
+              end
+            end
+
+            if !bad_rpms.empty?
+              bad_rpms.map!{|x| x = "  * #{x}"}
+              bad_rpms.unshift("ERROR: Untrusted RPMs found in the repository:")
+
+              fail(bad_rpms.join("\n"))
+            else
+              puts "Checksig succeeded"
+            end
+          ensure
+            remove_entry_secure temp_gpg_dir
+          end
+        end
+
+        desc <<-EOM
+          Run repoclosure on RPM files.
+
+            Finds all rpm files in the target dir and all of its subdirectories, then
+            reports which packages have unresolved dependencies. This needs to be run
+            after rake tasks tar:build and unpack if operating on the base SIMP repo.
+              * :target_dir  - The directory to assess. Default #{@build_dir}/SIMP.
+              * :aux_dir     - Auxillary repo glob to use when assessing. Default #{@build_dir}/Ext_*.
+                              Defaults to ''(empty) if :target_dir is not the system default.
+
+        EOM
+        task :repoclosure,[:target_dir,:aux_dir] => [:prep] do |t,args|
+          default_target = @pkg_dirs[:simp]
+          args.with_defaults(:target_dir => default_target)
+          if args.target_dir == default_target
+            args.with_defaults(:aux_dir => @pkg_dirs[:ext])
+          else
+            args.with_defaults(:aux_dir => '')
+          end
+
+          yum_conf_template = <<-EOF
+      [main]
+      keepcache=0
+      exactarch=1
+      obsoletes=1
+      gpgcheck=0
+      plugins=1
+      installonly_limit=5
+
+      <% repo_files.each do |repo| -%>
+      include=file://<%= repo %>
+      <% end -%>
+          EOF
+
+          yum_repo_template = <<-EOF
+      [<%= repo_name %>]
+      name=<%= repo_name %>
+      baseurl=file://<%= repo_path %>
+      enabled=1
+      gpgcheck=0
+      protect=1
+          EOF
+
+          fail "#{args.target_dir} does not exist!" if not File.directory?(args.target_dir)
+
+          begin
+            temp_pkg_dir = Dir.mktmpdir
+
+            mkdir_p("#{temp_pkg_dir}/repos/base")
+            mkdir_p("#{temp_pkg_dir}/repos/lookaside")
+            mkdir_p("#{temp_pkg_dir}/repodata")
+
+            Dir.glob(args.target_dir).each do |base_dir|
+              Find.find(base_dir) do |path|
+                if (path =~ /.*\.rpm$/) and (path !~ /.*.src\.rpm$/)
+                  sym_path = "#{temp_pkg_dir}/repos/base/#{File.basename(path)}"
+                  ln_s(path,sym_path) unless File.exists?(sym_path)
+                end
+              end
+            end
+
+            Dir.glob(args.aux_dir).each do |aux_dir|
+              Find.find(aux_dir) do |path|
+                if (path =~ /.*\.rpm$/) and (path !~ /.*.src\.rpm$/)
+                  sym_path = "#{temp_pkg_dir}/repos/lookaside/#{File.basename(path)}"
+                  ln_s(path,sym_path) unless File.exists?(sym_path)
+                end
+              end
+            end
+
+            Dir.chdir(temp_pkg_dir) do
+              repo_files = []
+              Dir.glob('repos/*').each do |repo|
+                if File.directory?(repo)
+                  Dir.chdir(repo) { sh %{createrepo .} }
+
+                  repo_name = File.basename(repo)
+                  repo_path = File.expand_path(repo)
+                  conf_file = "#{temp_pkg_dir}/#{repo_name}.conf"
+
+                  File.open(conf_file,'w') do |file|
+                    file.write(ERB.new(yum_repo_template,nil,'-').result(binding))
+                  end
+
+                  repo_files << conf_file
+                end
+              end
+
+              File.open('yum.conf', 'w') do |file|
+                file.write(ERB.new(yum_conf_template,nil,'-').result(binding))
+              end
+
+              cmd = 'repoclosure -c repodata -n -t -r base -l lookaside -c yum.conf'
+
+              if ENV['SIMP_BUILD_verbose'] == 'yes'
+                puts
+                puts '-'*80
+                puts "#### RUNNING: `#{cmd}`"
+                puts "     in path '#{Dir.pwd}'"
+                puts '-'*80
+              end
+              sh cmd
+            end
+          ensure
+            remove_entry_secure temp_pkg_dir
+          end
+        end
+
+        ##############################################################################
+        # Helper methods
+        ##############################################################################
+
+        # Takes a list of directories to hop into and perform builds within
+        # Needs to be passed the chroot path as well
+        #
+        # The task must be passed so that we can output the calling name in the
+        # status bar.
+        def build(chroot,dirs,task,add_to_autoreq=true,snapshot_release=false)
+          validate_in_mock_group?
+
+          mock_pre_check(chroot)
+
+          # Default package metadata for reference
+          default_metadata = YAML.load(File.read("#{@src_dir}/build/package_metadata_defaults.yaml"))
+
+          metadata = Parallel.map(
+            Array(dirs),
+            :in_processes => get_cpu_limit,
+            :progress => task.name
+          ) do |dir|
+            result = []
+
+            Dir.chdir(dir) do
+              if File.exist?('Rakefile')
+                # Read the package metadata file and proceed accordingly.
+                module_metadata = default_metadata
+                if File.exist?('build/package_metadata.yaml')
+                  module_metadata.merge!(YAML.load(File.read('build/package_metadata.yaml')))
+                end
+
+                # @simp_version should be set in the main Rakefile
+                build_module = false
+                Array(module_metadata['valid_versions']).each do |version_regex|
+                  build_module = Regexp.new("^#{version_regex}$").match(@simp_version)
+                  break if build_module
+                end
+
+                if build_module
+                  unique_build = (get_cpu_limit != 1)
+                  sh %{rake pkg:rpm[#{chroot},unique_build,#{snapshot_release}]}
+
+                  # Glob all generated rpms, and add their metadata to a result array.
+                  pkginfo = Hash.new
+                  Dir.glob('dist/*.rpm') do |rpm|
+                    if not rpm =~ /.*.src.rpm/ then
+                      # get_info from each generated rpm, not the spec file, so macros in the
+                      # metadata have already been resolved in the mock chroot.
+                      pkginfo = Simp::RPM.get_info(rpm)
+                      result << [pkginfo,module_metadata]
+                    end
+                  end
+                else
+                  puts "Warning: #{Simp::RPM.get_info(Dir.glob('build/*.spec').first)[:name]} is not \
+      valid against SIMP version #{@simp_version.gsub("%{?snapshot_release}","")} and will not be built."
+                end
+              else
+                puts "Warning: Could not find Rakefile in '#{dir}'"
+              end
+            end
+
+            result
+          end
+
+          metadata.each do |i|
+            # Each module could generate multiple rpms, each with its own metadata.
+            # Iterate over them to add all built rpms to autorequires.
+            i.each do |module_pkginfo,module_metadata|
+              next unless (module_pkginfo and module_metadata)
+
+              # Set up the autorequires
+              if add_to_autoreq and not module_metadata['optional']
+                # Register the package with the autorequires
+                mode = 'r+'
+                mode = 'w+' unless File.exist?("#{@src_dir}/build/autorequires")
+                autoreq_fh = File.open("#{@src_dir}/build/autorequires",mode)
+
+                begin
+                  autorequires = []
+                  autorequires += autoreq_fh.read.split("\n")
+                  autoreq_fh.rewind
+                  autoreq_fh.truncate(0)
+
+                  # The SIMP Rakefile expects the autorequires to be in this format.
+                  autorequires << "#{module_pkginfo[:name]} #{module_pkginfo[:version]} #{module_pkginfo[:release]}"
+                  autoreq_fh.puts(autorequires.sort.uniq.join("\n"))
+                ensure
+                  autoreq_fh.flush
+                  autoreq_fh.close
+                end
+              end
+            end
+          end
+        end
+
+        #desc "Checks the environment for building the DVD tarball
+        def check_dvd_env
+          ["#{@dvd_src}/isolinux","#{@dvd_src}/ks"].each do |dir|
+            File.directory?(dir)or raise "Environment not suitable: Unable to find directory '#{dir}'"
+          end
+        end
+
+        # Return a list of all puppet module directories with Rakefiles
+        def get_module_dirs
+          moddir = "#{@src_dir}/puppet/modules"
+
+          toret = []
+
+          Dir.glob("#{moddir}/*").map { |x| x = File.basename(x).chomp }.sort.each do |mod|
+            if File.exist?("#{moddir}/#{mod}/Rakefile")
+                toret << "#{moddir}/#{mod}"
+            end
+          end
+
+          toret
+        end
+
+        # Get a list of all of the mock configs available on the system.
+        def get_mock_configs
+          Dir.glob('/etc/mock/*.cfg').sort.map{ |x| x = File.basename(x,'.cfg')}
+        end
+
+        # Run some pre-checks to make sure that mock will work properly.
+        # Pass init=false if you do not want the function to initialize.
+        #
+        # Returns 'true' if the space is already initialized.
+        # FIXME: unique_name doesn't work
+        # FIXME: unique_name is never called
+        # FIXME: which is fortunate, because PKGNAME is never defined
+        def mock_pre_check(chroot,unique_name=false,init=true)
+          raise(Exception,"Could not find mock on your system, exiting") unless File.executable?('/usr/bin/mock')
+
+          mock_configs = get_mock_configs
+
+          if not chroot
+            fail("Error: No mock chroot provided. Your choices are:\n#{mock_configs.join("\n  ")}"
+            )
+          end
+          if not mock_configs.include?(chroot)
+            fail("Error: Invalid mock chroot provided. Your choices are:\n#{mock_configs.join("\n  ")}"
+            )
+          end
+
+          # Allow for building all modules in parallel.
+          @mock = "#{@mock} --uniqueext=#{PKGNAME}" if unique_name
+
+          # A simple test to see if the chroot is initialized
+          %x{#{@mock} -q --root #{chroot} --chroot "test -d /tmp" --quiet &> /dev/null}
+          initialized = $?.success?
+
+          if init and not initialized
+            cmd = %{#{@mock} --root #{chroot} --init}
+            sh cmd
+          end
+
+          initialized
+        end
+      end
+    end
+  end
+end
+