puppet 2.7.25 → 2.7.26

data/ext/packaging/tasks/jenkins_dynamic.rake

@@ -17,32 +17,35 @@ namespace :pl do
     task :uber_build => "pl:fetch" do
       # If we have a dirty source, bail, because changes won't get reflected in
       # the package builds
-      fail_on_dirty_source
+      Pkg::Util::Version.fail_on_dirty_source
 
       # Use JSON to parse the json part of the submission, so we want to fail
       # here also if JSON isn't available
-      require_library_or_fail 'json'
+      Pkg::Util.require_library_or_fail 'json'
 
       # The uber_build.xml.erb file is an XML erb template that will define a
       # job in Jenkins with all of the appropriate tasks
-      work_dir           = get_temp
+      work_dir           = Pkg::Util::File.mktemp
       template_dir       = File.join(File.dirname(__FILE__), '..', 'templates')
       templates          = ['repo.xml.erb', 'packaging.xml.erb']
-      templates.unshift('downstream.xml.erb') if ENV['DOWNSTREAM_JOB']
+      templates << ('downstream.xml.erb') if ENV['DOWNSTREAM_JOB']
 
       # Generate an XML file for every job configuration erb and attempt to
       # create a jenkins job from that XML config
       templates.each do |t|
-        erb_file  = File.join(template_dir, t)
+        erb_template  = File.join(template_dir, t)
         xml_file = File.join(work_dir, t.gsub('.erb', ''))
-        erb(erb_file, xml_file)
-        job_name  = "#{@build.project}-#{t.gsub('.xml.erb','')}-#{@build.build_date}-#{@build.ref}"
+        Pkg::Util::File.erb_file(erb_template, xml_file, nil, :binding => Pkg::Config.get_binding)
+        job_name  = "#{Pkg::Config.project}-#{t.gsub('.xml.erb','')}-#{Pkg::Config.build_date}-#{Pkg::Config.ref}"
         puts "Checking for existence of #{job_name}..."
         if jenkins_job_exists?(job_name)
-          raise "Job #{job_name} already exists on #{@build.jenkins_build_host}"
+          raise "Job #{job_name} already exists on #{Pkg::Config.jenkins_build_host}"
         else
           retry_on_fail(:times => 3) do
             url = create_jenkins_job(job_name, xml_file)
+            if t == "packaging.xml.erb"
+              ENV["PACKAGE_BUILD_URL"] = url
+            end
             puts "Verifying job created successfully..."
             unless jenkins_job_exists?(job_name)
               raise "Unable to verify Jenkins job, trying again..."
@@ -52,7 +55,7 @@ namespace :pl do
         end
       end
       rm_r work_dir
-      packaging_name = "#{@build.project}-packaging-#{@build.build_date}-#{@build.ref}"
+      packaging_name = "#{Pkg::Config.project}-packaging-#{Pkg::Config.build_date}-#{Pkg::Config.ref}"
       invoke_task("pl:jenkins:trigger_dynamic_job", packaging_name)
     end
 
@@ -62,20 +65,20 @@ namespace :pl do
     task :trigger_dynamic_job, :name do |t, args|
       name = args.name
 
-      properties = @build.params_to_yaml
+      properties = Pkg::Config.config_to_yaml
       bundle = git_bundle('HEAD')
 
       # Create a string of metrics to send to Jenkins for data analysis
-      if @build.pe_version
-        metrics = "#{ENV['USER']}~#{@build.version}~#{@build.pe_version}~#{@build.team}"
+      if Pkg::Config.pe_version
+        metrics = "#{ENV['USER']}~#{Pkg::Config.version}~#{Pkg::Config.pe_version}~#{Pkg::Config.team}"
       else
-        metrics = "#{ENV['USER']}~#{@build.version}~N/A~#{@build.team}"
+        metrics = "#{ENV['USER']}~#{Pkg::Config.version}~N/A~#{Pkg::Config.team}"
       end
 
       # Construct the parameters, which is an array of hashes we turn into JSON
       parameters = [{ "name" => "BUILD_PROPERTIES", "file"  => "file0" },
                     { "name" => "PROJECT_BUNDLE",   "file"  => "file1" },
-                    { "name" => "PROJECT",          "value" => "#{@build.project}" },
+                    { "name" => "PROJECT",          "value" => "#{Pkg::Config.project}" },
                     { "name" => "METRICS",          "value" => "#{metrics}"}]
 
       # Contruct the json string
@@ -86,18 +89,18 @@ namespace :pl do
       curl_args =  [
       "-Fname=BUILD_PROPERTIES", "-Ffile0=@#{properties}",
       "-Fname=PROJECT_BUNDLE"  , "-Ffile1=@#{bundle}",
-      "-Fname=PROJECT"         , "-Fvalue=#{@build.project}",
+      "-Fname=PROJECT"         , "-Fvalue=#{Pkg::Config.project}",
       "-Fname=METRICS"         , "-Fvalue=#{metrics}",
       "-FSubmit=Build",
       "-Fjson=#{json.to_json}",
       ]
 
       # Contstruct the job url
-      trigger_url = "#{@build.jenkins_build_host}/job/#{name}/build"
+      trigger_url = "#{Pkg::Config.jenkins_build_host}/job/#{name}/build"
 
       if curl_form_data(trigger_url, curl_args)
-        print_url_info("#{@build.jenkins_build_host}/job/#{name}")
-        puts "Your packages will be available at #{@build.distribution_server}:#{@build.jenkins_repo_path}/#{@build.project}/#{@build.ref}"
+        print_url_info("http://#{Pkg::Config.jenkins_build_host}/job/#{name}")
+        puts "Your packages will be available at #{Pkg::Config.distribution_server}:#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}"
       else
         fail "An error occurred submitting the job to jenkins. Take a look at the preceding http response for more info."
       end
@@ -113,7 +116,7 @@ namespace :pe do
   namespace :jenkins do
     desc "Dynamic Jenkins UBER build: Build all the things with ONE job"
     task :uber_build do
-      check_var("PE_VER", @build.pe_version)
+      check_var("PE_VER", Pkg::Config.pe_version)
       invoke_task("pl:jenkins:uber_build")
     end
   end

data/ext/packaging/tasks/load_extras.rake

@@ -0,0 +1,21 @@
+# The pl:load_extras tasks is intended to load variables
+# from the extra yaml file downloaded by the pl:fetch task.
+# The goal is to be able to augment/override settings in the
+# source project's build_data.yaml and project_data.yaml with
+# Puppet Labs-specific data, rather than having to clutter the
+# generic tasks with data not generally useful outside the
+# PL Release team
+namespace :pl do
+  task :load_extras, :tempdir do |t, args|
+    unless ENV['PARAMS_FILE'] && ENV['PARAMS_FILE'] != ''
+      tempdir = args.tempdir
+      raise "pl:load_extras requires a directory containing extras data" if tempdir.nil?
+      Pkg::Config.config_from_yaml("#{tempdir}/#{Pkg::Config.builder_data_file}")
+
+      # Environment variables take precedence over those loaded from configs,
+      # so we make sure that any we clobbered are reset.
+      Pkg::Config.load_envvars
+    end
+  end
+end
+

data/ext/packaging/tasks/mock.rake

@@ -18,10 +18,10 @@
 # e.g.,
 # pkg/el-5-i386/*.rpm
 def mock_artifact(mock_config, cmd_args)
-  unless mock = find_tool('mock')
+  unless mock = Pkg::Util::Tool.find_tool('mock')
     raise "mock is required for building srpms with mock. Please install mock and try again."
   end
-  randomize = @build.random_mockroot
+  randomize = Pkg::Config.random_mockroot
   configdir = nil
   basedir = File.join('var', 'lib', 'mock')
 
@@ -91,7 +91,7 @@ end
 # and  pl-fedora-17-i386 = "fedora"
 #
 def mock_el_family(mock_config)
-  if @build.build_pe
+  if Pkg::Config.build_pe
     family = mock_config.split('-')[2][/[a-z]+/]
   else
     first, second = mock_config.split('-')
@@ -113,7 +113,7 @@ end
 # and "pl-fedora-17-i386" = "17"
 #
 def mock_el_ver(mock_config)
-  if @build.build_pe
+  if Pkg::Config.build_pe
     version = mock_config.split('-')[2][/[0-9]+/]
   else
     first, second, third = mock_config.split('-')
@@ -151,7 +151,7 @@ def build_rpm_with_mock(mocks)
   mocks.split(' ').each do |mock_config|
     family  = mock_el_family(mock_config)
     version = mock_el_ver(mock_config)
-    subdir  = is_final? ? 'products' : 'devel'
+    subdir  = Pkg::Util::Version.is_final? ? 'products' : 'devel'
     bench = Benchmark.realtime do
       # Set up the rpmbuild dir in a temp space, with our tarball and spec
       workdir = prep_rpm_build_dir
@@ -168,7 +168,7 @@ def build_rpm_with_mock(mocks)
       rpms.each do |rpm|
         rpm.strip!
 
-        if @build.build_pe
+        if Pkg::Config.build_pe
           %x{mkdir -p pkg/pe/rpm/#{family}-#{version}-{srpms,i386,x86_64}}
           case File.basename(rpm)
             when /debuginfo/
@@ -181,7 +181,7 @@ def build_rpm_with_mock(mocks)
               cp_pr(rpm, "pkg/pe/rpm/#{family}-#{version}-x86_64")
             when /noarch/
               cp_pr(rpm, "pkg/pe/rpm/#{family}-#{version}-i386")
-              ln("pkg/pe/rpm/#{family}-#{version}-i386/#{File.basename(rpm)}", "pkg/pe/rpm/#{family}-#{version}-x86_64/")
+              FileUtils.ln("pkg/pe/rpm/#{family}-#{version}-i386/#{File.basename(rpm)}", "pkg/pe/rpm/#{family}-#{version}-x86_64/", :force => true, :verbose => true)
           end
         else
           %x{mkdir -p pkg/#{family}/#{version}/#{subdir}/{SRPMS,i386,x86_64}}
@@ -196,14 +196,14 @@ def build_rpm_with_mock(mocks)
               cp_pr(rpm, "pkg/#{family}/#{version}/#{subdir}/x86_64")
             when /noarch/
               cp_pr(rpm, "pkg/#{family}/#{version}/#{subdir}/i386")
-              ln("pkg/#{family}/#{version}/#{subdir}/i386/#{File.basename(rpm)}", "pkg/#{family}/#{version}/#{subdir}/x86_64/")
+              FileUtils.ln("pkg/#{family}/#{version}/#{subdir}/i386/#{File.basename(rpm)}", "pkg/#{family}/#{version}/#{subdir}/x86_64/", :force => true, :verbose => true)
           end
         end
       end
       # To avoid filling up the system with our random mockroots, we should
       # clean up. However, this requires sudo. If we don't have sudo, we'll
       # just fail and not clean up, but warn the user about it.
-      if @build.random_mockroot
+      if Pkg::Config.random_mockroot
         %x{sudo -n echo 'Cleaning build root.'}
         if $?.success?
           sh "sudo -n rm -r #{File.dirname(srpm)}" unless File.dirname(srpm).nil?
@@ -231,7 +231,7 @@ def mock_with_basedir(mock, basedir)
   config = IO.readlines(mock)
   basedir = "config_opts['basedir'] = '#{basedir}'"
   config.unshift(basedir)
-  tempdir = get_temp
+  tempdir = Pkg::Util::File.mktemp
   newmock = File.join(tempdir, File.basename(mock))
   File.open(newmock, 'w') { |f| f.puts config }
   newmock
@@ -245,7 +245,7 @@ end
 # configuration file and returns the path to the new configuration dir.
 #
 def setup_mock_config_dir(mock)
-  tempdir = get_temp
+  tempdir = Pkg::Util::File.mktemp
   cp File.join('/', 'etc', 'mock', 'site-defaults.cfg'), tempdir
   cp File.join('/', 'etc', 'mock', 'logging.ini'), tempdir
   cp mock, tempdir
@@ -259,7 +259,7 @@ end
 #
 def randomize_mock_config_dir(mock_config)
   # basedir will be the location of our temporary mock root
-  basedir = get_temp
+  basedir = Pkg::Util::File.mktemp
   chown("#{ENV['USER']}", "mock", basedir)
   # Mock requires the sticky bit be set on the basedir
   chmod(02775, basedir)
@@ -278,13 +278,13 @@ end
 namespace :pl do
   desc "Use default mock to make a final rpm, keyed to PL infrastructure, pass MOCK to specify config"
   task :mock => "package:tar" do
-    # If default mock isn't specified, just take the first one in the @build.final_mocks list
-    @build.default_mock ||= @build.final_mocks.split(' ')[0]
-    build_rpm_with_mock(@build.default_mock)
+    # If default mock isn't specified, just take the first one in the Pkg::Config.final_mocks list
+    Pkg::Config.default_mock ||= Pkg::Config.final_mocks.split(' ')[0]
+    build_rpm_with_mock(Pkg::Config.default_mock)
   end
 
   desc "Use specified mocks to make rpms, keyed to PL infrastructure, pass MOCK to specifiy config"
   task :mock_all => "package:tar" do
-    build_rpm_with_mock(@build.final_mocks)
+    build_rpm_with_mock(Pkg::Config.final_mocks)
   end
 end

data/ext/packaging/tasks/pe_deb.rake

@@ -1,9 +1,9 @@
 # "Alias" tasks for PE - these just point at the standard pl: tasks. They exist
 # for ease of aggregation with PE-specific tasks that _are_ actually different
 # from their "pl" counterparts
-if @build.build_pe
+if Pkg::Config.build_pe
   namespace :pe do
-    desc "Create a PE deb from this repo using the default cow #{@build.default_cow}."
+    desc "Create a PE deb from this repo using the default cow #{Pkg::Config.default_cow}."
     task :deb => "pl:deb"
 
     desc "Create PE debs from this git repository using all cows specified in build_defaults yaml"

data/ext/packaging/tasks/pe_remote.rake

@@ -1,33 +1,33 @@
 # PE remote tasks
 # We keep these around for backwards compatibility and as a backup in case the
 # jenkins infrastructure fails. We hide them to reduce task clutter
-if @build.build_pe
+if Pkg::Config.build_pe
   namespace :pe do
     namespace :remote do
       task :deb => 'pl:fetch' do
-        ENV['PE_VER'] ||= @build.pe_version
+        ENV['PE_VER'] ||= Pkg::Config.pe_version
         check_var('PE_VER', ENV['PE_VER'])
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pe:deb PE_BUILD=#{@build.build_pe} TEAM=#{@build.team} PE_VER=#{ENV['PE_VER']}")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pe:deb PE_BUILD=#{Pkg::Config.build_pe} TEAM=#{Pkg::Config.team} PE_VER=#{ENV['PE_VER']}")
       end
 
       task :deb_all => 'pl:fetch' do
-        ENV['PE_VER'] ||= @build.pe_version
+        ENV['PE_VER'] ||= Pkg::Config.pe_version
         check_var('PE_VER', ENV['PE_VER'])
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pe:deb_all PE_BUILD=#{@build.build_pe} COW='#{@build.cows}' TEAM=#{@build.team} PE_VER=#{ENV['PE_VER']}")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pe:deb_all PE_BUILD=#{Pkg::Config.build_pe} COW='#{Pkg::Config.cows}' TEAM=#{Pkg::Config.team} PE_VER=#{ENV['PE_VER']}")
       end
 
       task :mock => 'pl:fetch' do
-        ENV['PE_VER'] ||= @build.pe_version
+        ENV['PE_VER'] ||= Pkg::Config.pe_version
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pe:mock PE_BUILD=#{@build.build_pe} TEAM=#{@build.team} PE_VER=#{ENV['PE_VER']}")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pe:mock PE_BUILD=#{Pkg::Config.build_pe} TEAM=#{Pkg::Config.team} PE_VER=#{ENV['PE_VER']}")
       end
 
       task :mock_all => 'pl:fetch' do
-        ENV['PE_VER'] ||= @build.pe_version
+        ENV['PE_VER'] ||= Pkg::Config.pe_version
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pe:mock_all PE_BUILD=#{@build.build_pe} MOCK='#{@build.final_mocks}' TEAM=#{@build.team} PE_VER=#{ENV['PE_VER']}")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pe:mock_all PE_BUILD=#{Pkg::Config.build_pe} MOCK='#{Pkg::Config.final_mocks}' TEAM=#{Pkg::Config.team} PE_VER=#{ENV['PE_VER']}")
       end
 
       task :all => ['clean', 'pl:fetch'] do

data/ext/packaging/tasks/pe_rpm.rake

@@ -1,4 +1,4 @@
-if @build.build_pe
+if Pkg::Config.build_pe
   namespace :pe do
     desc "Build a PE rpm using rpmbuild (requires all BuildRequires, rpmbuild, etc)"
     task :rpm => "package:rpm"

data/ext/packaging/tasks/pe_ship.rake

@@ -1,20 +1,20 @@
-if @build.build_pe
+if Pkg::Config.build_pe
   namespace :pe do
-    desc "ship PE rpms to #{@build.yum_host}"
+    desc "ship PE rpms to #{Pkg::Config.yum_host}"
     task :ship_rpms => "pl:fetch" do
-      empty_dir?("pkg/pe/rpm") and fail "The 'pkg/pe/rpm' directory has no packages. Did you run rake pe:deb?"
-      target_path = ENV['YUM_REPO'] ? ENV['YUM_REPO'] : "#{@build.yum_repo_path}/#{@build.pe_version}/repos/"
+      Pkg::Util::File.empty_dir?("pkg/pe/rpm") and fail "The 'pkg/pe/rpm' directory has no packages. Did you run rake pe:deb?"
+      target_path = ENV['YUM_REPO'] ? ENV['YUM_REPO'] : "#{Pkg::Config.yum_repo_path}/#{Pkg::Config.pe_version}/repos/"
       retry_on_fail(:times => 3) do
-        rsync_to('pkg/pe/rpm/', @build.yum_host, target_path)
+        rsync_to('pkg/pe/rpm/', Pkg::Config.yum_host, target_path)
       end
-      if @build.team == 'release'
+      if Pkg::Config.team == 'release'
         Rake::Task["pe:remote:update_yum_repo"].invoke
       end
     end
 
-    desc "Ship PE debs to #{@build.apt_host}"
+    desc "Ship PE debs to #{Pkg::Config.apt_host}"
     task :ship_debs => "pl:fetch" do
-      empty_dir?("pkg/pe/deb") and fail "The 'pkg/pe/deb' directory has no packages!"
+      Pkg::Util::File.empty_dir?("pkg/pe/deb") and fail "The 'pkg/pe/deb' directory has no packages!"
       target_path = ENV['APT_REPO']
 
       #   If APT_REPO isn't specified as an environment variable, we use a temporary one
@@ -30,8 +30,8 @@ if @build.build_pe
       Dir["pkg/pe/deb/*"].each do |dist|
         dist = File.basename(dist)
         unless target_path
-          puts "Creating temporary incoming dir on #{@build.apt_host}"
-          target_path = %x{ssh -t #{@build.apt_host} 'mktemp -d -t incoming-XXXXXX'}.chomp
+          puts "Creating temporary incoming dir on #{Pkg::Config.apt_host}"
+          target_path = %x{ssh -t #{Pkg::Config.apt_host} 'mktemp -d -t incoming-XXXXXX'}.chomp
         end
 
         #   For reprepro, we ship just the debs into an incoming dir. On the remote end,
@@ -49,15 +49,16 @@ if @build.build_pe
         #                 |_precise/*.deb
         #                 |_wheezy/*.deb
         #
-        puts "Shipping PE debs to apt repo 'incoming' dir on #{@build.apt_host}"
+        puts "Shipping PE debs to apt repo 'incoming' dir on #{Pkg::Config.apt_host}"
         retry_on_fail(:times => 3) do
           Dir["pkg/pe/deb/#{dist}/*.deb"].each do |deb|
-            remote_ssh_cmd(@build.apt_host, "mkdir -p '#{target_path}/#{dist}'")
-            rsync_to(deb, @build.apt_host, "#{target_path}/#{dist}/#{File.basename(deb)}")
+            remote_ssh_cmd(Pkg::Config.apt_host, "mkdir -p '#{target_path}/#{dist}'")
+            rsync_to(deb, Pkg::Config.apt_host, "#{target_path}/#{dist}/#{File.basename(deb)}")
           end
         end
 
-        if @build.team == 'release'
+        if Pkg::Config.team == 'release'
+          Rake::Task["pe:remote:apt"].reenable
           Rake::Task["pe:remote:apt"].invoke(target_path, dist)
         end
 
@@ -80,18 +81,18 @@ if @build.build_pe
       #   by newer ones. To handle this, we make everything we ship to the archive
       #   directories immutable, after rsyncing out.
       #
-      base_path = "#{@build.apt_repo_path}/#{@build.pe_version}/repos"
+      base_path = "#{Pkg::Config.apt_repo_path}/#{Pkg::Config.pe_version}/repos"
 
-      puts "Shipping all built artifacts to to archive directories on #{@build.apt_host}"
+      puts "Shipping all built artifacts to to archive directories on #{Pkg::Config.apt_host}"
 
-      @build.cows.split(' ').map { |i| i.sub('.cow','') }.each do |cow|
+      Pkg::Config.cows.split(' ').map { |i| i.sub('.cow','') }.each do |cow|
         _base, dist, arch = cow.split('-')
-        unless empty_dir? "pkg/pe/deb/#{dist}"
+        unless Pkg::Util::File.empty_dir? "pkg/pe/deb/#{dist}"
           archive_path = "#{base_path}/#{dist}-#{arch}"
 
           # Ship arch-specific debs to correct dir, e.g. 'squeeze-i386'
           unless Dir["pkg/pe/deb/#{dist}/pe-*_#{arch}.deb"].empty?
-            rsync_to("pkg/pe/deb/#{dist}/pe-*_#{arch}.deb --ignore-existing", @build.apt_host, "#{archive_path}/" )
+            rsync_to("pkg/pe/deb/#{dist}/pe-*_#{arch}.deb --ignore-existing", Pkg::Config.apt_host, "#{archive_path}/" )
           end
 
           # Ship all-arch debs to same dist-location, but to all known
@@ -101,16 +102,16 @@ if @build.build_pe
 
           unless Dir["pkg/pe/deb/#{dist}/pe-*_all.deb"].empty?
             if dist =~ /cumulus/
-              rsync_to("pkg/pe/deb/#{dist}/pe-*_all.deb --ignore-existing", @build.apt_host, "#{base_path}/#{dist}-powerpc/")
+              rsync_to("pkg/pe/deb/#{dist}/pe-*_all.deb --ignore-existing", Pkg::Config.apt_host, "#{base_path}/#{dist}-powerpc/")
             else
-              rsync_to("pkg/pe/deb/#{dist}/pe-*_all.deb --ignore-existing", @build.apt_host, "#{base_path}/#{dist}-i386/")
-              rsync_to("pkg/pe/deb/#{dist}/pe-*_all.deb --ignore-existing", @build.apt_host, "#{base_path}/#{dist}-amd64/")
+              rsync_to("pkg/pe/deb/#{dist}/pe-*_all.deb --ignore-existing", Pkg::Config.apt_host, "#{base_path}/#{dist}-i386/")
+              rsync_to("pkg/pe/deb/#{dist}/pe-*_all.deb --ignore-existing", Pkg::Config.apt_host, "#{base_path}/#{dist}-amd64/")
             end
           end
 
           unless Dir["pkg/pe/deb/#{dist}/pe-*"].select { |i| i !~ /^.*\.deb$/ }.empty?
             # Ship source files to source dir, e.g. 'squeeze-source'
-            rsync_to("pkg/pe/deb/#{dist}/pe-* --exclude *.deb --ignore-existing", @build.apt_host, "#{base_path}/#{dist}-source")
+            rsync_to("pkg/pe/deb/#{dist}/pe-* --exclude *.deb --ignore-existing", Pkg::Config.apt_host, "#{base_path}/#{dist}-source")
           end
 
           files = Dir["pkg/pe/deb/#{dist}/pe-*{_#{arch},all}.deb"].map { |f| "#{archive_path}/#{File.basename(f)}" }
@@ -118,17 +119,27 @@ if @build.build_pe
           files += Dir["pkg/pe/deb/#{dist}/pe-*"].select { |f| f !~ /^.*\.deb$/ }.map { |f| "#{base_path}/#{dist}-source/#{File.basename(f)}" }
 
           unless files.empty?
-            remote_set_immutable(@build.apt_host, files)
+            remote_set_immutable(Pkg::Config.apt_host, files)
           end
         end
       end
-
     end
 
     namespace :remote do
-      desc "Update remote rpm repodata for PE on #{@build.yum_host}"
+      desc "Update remote rpm repodata for PE on #{Pkg::Config.yum_host}"
       task :update_yum_repo => "pl:fetch" do
-        remote_ssh_cmd(@build.yum_host, "for dir in  $(find #{@build.apt_repo_path}/#{@build.pe_version}/repos/{sles,el}* -type d | grep -v repodata | grep -v cache | xargs)  ; do pushd $dir; sudo createrepo -q -d --update .; popd &> /dev/null ; done; sync")
+        repo_base_path = File.join(Pkg::Config.yum_repo_path, Pkg::Config.pe_version, "repos")
+        mock_paths = Pkg::Config.final_mocks.split.map {|mock| "#{mock_el_family(mock)}-#{mock_el_ver(mock)}"}
+
+        # This entire command is going to be passed across SSH, but it's unwieldy on a
+        # single line. By breaking it into a series of concatenated strings, we can maintain
+        # a semblance of formatting and structure (nevermind readability).
+        command  = %{for dir in #{repo_base_path}/{#{mock_paths.join(",")}}-*; do}
+        command += %{  sudo createrepo --checksum=sha --quiet --database --update $dir; }
+        command += %{done; }
+        command += %{sync}
+
+        remote_ssh_cmd(Pkg::Config.yum_host, command)
       end
 
       #   the repsimple application is a small wrapper around reprepro, the purpose of
@@ -137,30 +148,30 @@ if @build.build_pe
       #   command expects an incoming directory option containing .deb files.
       #   Per previous comments, the incoming directory must contain subdirectories named
       #   for debian distributions.
-      desc "Remotely add shipped packages to apt repo on #{@build.apt_host}"
+      desc "Remotely add shipped packages to apt repo on #{Pkg::Config.apt_host}"
       task :apt, :incoming, :dist do |t, args|
         dist = args.dist
         if dist =~ /cumulus/
-          reprepro_confdir = "/etc/reprepro/networking/#{@build.pe_version}/cumulus"
-          reprepro_basedir = "/opt/enterprise/networking/#{@build.pe_version}/cumulus"
-          reprepro_dbdir = "/var/lib/reprepro/networking/#{@build.pe_version}/cumulus"
+          reprepro_confdir = "/etc/reprepro/networking/#{Pkg::Config.pe_version}/cumulus"
+          reprepro_basedir = "/opt/enterprise/networking/#{Pkg::Config.pe_version}/cumulus"
+          reprepro_dbdir = "/var/lib/reprepro/networking/#{Pkg::Config.pe_version}/cumulus"
         else
-          reprepro_confdir = "/etc/reprepro/#{@build.pe_version}"
-          reprepro_basedir = "#{@build.apt_repo_path}/#{@build.pe_version}/repos/debian"
-          reprepro_dbdir = "/var/lib/reprepro/#{@build.pe_version}"
+          reprepro_confdir = "/etc/reprepro/#{Pkg::Config.pe_version}"
+          reprepro_basedir = "#{Pkg::Config.apt_repo_path}/#{Pkg::Config.pe_version}/repos/debian"
+          reprepro_dbdir = "/var/lib/reprepro/#{Pkg::Config.pe_version}"
         end
 
         incoming_dir = args.incoming
         incoming_dir or fail "Adding packages to apt repo requires an incoming directory"
         invoke_task("pl:fetch")
-        remote_ssh_cmd(@build.apt_host, "/usr/bin/repsimple add_all \
+        remote_ssh_cmd(Pkg::Config.apt_host, "/usr/bin/repsimple add_all \
             --confdir #{reprepro_confdir} \
             --basedir #{reprepro_basedir} \
             --databasedir #{reprepro_dbdir} \
             --incomingdir #{incoming_dir}")
 
-        puts "Cleaning up apt repo 'incoming' dir on #{@build.apt_host}"
-        remote_ssh_cmd(@build.apt_host, "rm -r #{incoming_dir}")
+        puts "Cleaning up apt repo 'incoming' dir on #{Pkg::Config.apt_host}"
+        remote_ssh_cmd(Pkg::Config.apt_host, "rm -r #{incoming_dir}")
 
       end
     end