puppet 2.7.25 → 2.7.26

data/ext/packaging/tasks/pe_sign.rake

@@ -1,7 +1,7 @@
 # The sign_legacy_rpm and sign_rpm methods are defined in sign.rake
 # This is just adapted for the 'PE' layout
 
-if @build.build_pe
+if Pkg::Config.build_pe
   namespace :pe do
     desc "Sign all staged in rpms in pkg"
     task :sign_rpms do
@@ -10,14 +10,14 @@ if @build.build_pe
       # Find x86_64 noarch rpms that have been created as hard links and remove them
       rm_r Dir["pkg/pe/rpm/*-*-x86_64/*.noarch.rpm"]
       # We'll sign the remaining noarch
-      sign_dists = 'el5', 'el6', 'sles11'
+      sign_dists = 'el4', 'el5', 'el6', 'el7', 'sles11'
       ['i386', 'x86_64'].each do |arch|
         sign_dists.each do |dist|
           family=dist[/[a-z]+/]
           version=dist[/[0-9]+/]
           rpm_stagedir        = "pkg/pe/rpm/#{family}-#{version}-#{arch}/*.rpm"
           srpm_stagedir       = "pkg/pe/rpm/#{family}-#{version}-srpms/*.rpm"
-          if family == 'el' and version == '6'
+          if family == 'el' and version >= '6'
             modern_rpms += FileList[rpm_stagedir] + FileList[srpm_stagedir]
           else
             old_rpms += FileList[rpm_stagedir] + FileList[srpm_stagedir]
@@ -31,7 +31,7 @@ if @build.build_pe
         dir = rpm.split('/')[-2]
         family, version, _arch = dir.split('-')
         cd File.dirname(rpm) do
-          ln File.basename(rpm), File.join('..', "#{family}-#{version}-x86_64")
+          FileUtils.ln(File.basename(rpm), File.join('..', "#{family}-#{version}-x86_64"), :force => true, :verbose => true)
         end
       end
     end
@@ -40,7 +40,7 @@ if @build.build_pe
     # this is a separate task we can pull out later.
     desc "Sign all debian changes files staged in pkg/pe"
     task :sign_deb_changes do
-      load_keychain if has_tool('keychain')
+      load_keychain if Pkg::Util::Tool.find_tool('keychain')
       sign_deb_changes("pkg/pe/deb/*/*.changes") unless Dir["pkg/pe/deb/*/*.changes"].empty?
     end
   end

data/ext/packaging/tasks/release.rake

@@ -6,11 +6,11 @@ namespace :pl do
     if confirm_ship(FileList["pkg/*.gem"])
       invoke_task("pl:ship_gem")
     end
-  end if @build.build_gem
+  end if Pkg::Config.build_gem
 
   task :release_deb_rc do
     deprecate("pl:release_deb_rc", "pl:release_deb")
-    load_keychain if has_tool('keychain')
+    load_keychain if Pkg::Util::Tool.find_tool('keychain')
     invoke_task("pl:deb_all_rc")
     invoke_task("pl:sign_deb_changes")
     if confirm_ship(FileList["pkg/deb/**/*"])
@@ -20,7 +20,7 @@ namespace :pl do
 
   task :release_deb_final do
     deprecate("pl:release_deb_final", "pl:release_deb")
-    load_keychain if has_tool('keychain')
+    load_keychain if Pkg::Util::Tool.find_tool('keychain')
     invoke_task("pl:deb_all")
     invoke_task("pl:sign_deb_changes")
     if confirm_ship(FileList["pkg/deb/**/*"])
@@ -29,7 +29,7 @@ namespace :pl do
   end
 
   task :release_deb do
-    load_keychain if has_tool('keychain')
+    load_keychain if Pkg::Util::Tool.find_tool('keychain')
     invoke_task("pl:deb_all")
     invoke_task("pl:sign_deb_changes")
     if confirm_ship(FileList["pkg/deb/**/*"])
@@ -80,7 +80,7 @@ namespace :pl do
       if confirm_ship(FileList["pkg/apple/*.dmg"])
         Rake::Task["pl:ship_dmg"].execute
       end
-    end if @build.build_dmg
+    end if Pkg::Config.build_dmg
 
     task :release_ips => 'pl:fetch' do
       Rake::Task['pl:ips'].invoke

data/ext/packaging/tasks/remote_build.rake

@@ -4,13 +4,13 @@ if File.exist?("#{ENV['HOME']}/.packaging")
   namespace 'pl' do
     namespace :remote do
       task :build, :host, :treeish, :task, :tar do |t, args|
-        fail_on_dirty_source
+        Pkg::Util::Version.fail_on_dirty_source
         host                    = args.host
         treeish                 = args.treeish
         task                    = args.task
         tar                     = args.tar
         remote_repo             = remote_bootstrap(host, treeish, tar)
-        build_params            = remote_buildparams(host, @build)
+        build_params            = remote_buildparams(host, Pkg::Config)
         STDOUT.puts "Beginning package build on #{host}"
         remote_ssh_cmd(host, "cd #{remote_repo} ; rake #{task} PARAMS_FILE=#{build_params} ANSWER_OVERRIDE=no PGUSER=#{ENV['PGUSER']} PGDATABASE=#{ENV['PGDATABASE']} PGHOST=#{ENV['PGHOST']}")
         rsync_from("#{remote_repo}/pkg/", host, 'pkg/')
@@ -22,107 +22,107 @@ if File.exist?("#{ENV['HOME']}/.packaging")
       task :remote_deb_rc => 'pl:fetch' do
         deprecate("pl:remote_deb_rc", "pl:remote:release_deb")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:release_deb_rc")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pl:release_deb_rc")
       end
 
       task :remote_deb_rc_build => 'pl:fetch' do
         deprecate("pl:remote_deb_rc_build", "pl:remote:deb_all")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:deb_all_rc")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pl:deb_all_rc")
       end
 
       task :remote_deb_final => 'pl:fetch' do
         deprecate("pl:remote_deb_final", "pl:remote:release_deb")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:release_deb_final")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pl:release_deb_final")
       end
 
       task :remote_deb_final_build => 'pl:fetch' do
         deprecate("pl:remote_deb_final_build", "pl:remote:deb_all")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:deb_all")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pl:deb_all")
       end
 
       task :deb => 'pl:fetch' do
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:deb")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pl:deb")
       end
 
       task :deb_all => 'pl:fetch' do
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:deb_all")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pl:deb_all")
       end
 
       task :release_deb => 'pl:fetch'  do
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:release_deb")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.deb_build_host, 'HEAD', "pl:release_deb")
       end
 
       task :remote_rpm_rc => 'pl:fetch' do
         deprecate("pl:remote_rpm_rc", "pl:remote:release_rpm")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:release_rpm_rc")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pl:release_rpm_rc")
       end
 
       task :remote_rpm_rc_build => 'pl:fetch' do
         deprecate("pl:remote_rpm_rc_build", "pl:remote:mock_all")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:mock_rc")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pl:mock_rc")
       end
 
       task :remote_rpm_final => 'pl:fetch' do
         deprecate("pl:remote_rpm_final", "pl:remote:release_rpm")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:release_rpm_final")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pl:release_rpm_final")
       end
 
       task :release_rpm => 'pl:fetch' do
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:release_rpm")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pl:release_rpm")
       end
 
       task :remote_mock_final => 'pl:fetch' do
         deprecate("pl:remote_mock_final", "pl:remote:mock_all")
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:mock_final")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pl:mock_final")
       end
 
       task :mock => 'pl:fetch' do
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:mock")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pl:mock")
       end
 
       task :mock_all => 'pl:fetch' do
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:mock_all")
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.rpm_build_host, 'HEAD', "pl:mock_all")
       end
 
       task :ips => 'pl:fetch' do
         Rake::Task["pl:remote:build"].reenable
-        Rake::Task["pl:remote:build"].invoke(@build.ips_build_host, 'HEAD', 'pl:ips', 'gtar')
-      end if @build.build_ips
+        Rake::Task["pl:remote:build"].invoke(Pkg::Config.ips_build_host, 'HEAD', 'pl:ips', 'gtar')
+      end if Pkg::Config.build_ips
 
       task :dmg => 'pl:fetch' do
         # Because we use rvmsudo for apple, we end up replicating the :remote_build task
-        host                    = @build.osx_build_host
+        host                    = Pkg::Config.osx_build_host
         treeish                 = 'HEAD'
         task                    = "package:apple"
         remote_repo             = remote_bootstrap(host, treeish)
-        build_params            = remote_buildparams(host, @build)
+        build_params            = remote_buildparams(host, Pkg::Config)
         puts "Beginning package build on #{host}"
         remote_ssh_cmd(host, "cd #{remote_repo} ; rvmsudo rake #{task} PARAMS_FILE=#{build_params} PGUSER=#{ENV['PGUSER']} PGDATABASE=#{ENV['PGDATABASE']} PGHOST=#{ENV['PGHOST']}")
         rsync_from("#{remote_repo}/pkg/apple", host, 'pkg/')
         remote_ssh_cmd(host, "sudo rm -rf #{remote_repo}")
         STDOUT.puts "packages from #{host} staged in pkg/ directory"
-      end if @build.build_dmg
+      end if Pkg::Config.build_dmg
     end # remote namespace
 
     task :uber_rc do
       deprecate("pl:uber_rc", "pl:uber_release")
-      Rake::Task["package:gem"].invoke if @build.build_gem
+      Rake::Task["package:gem"].invoke if Pkg::Config.build_gem
       Rake::Task["pl:remote_deb_rc"].invoke
       Rake::Task["pl:remote_rpm_rc"].execute
-      Rake::Task["pl:remote:dmg"].execute if @build.build_dmg
+      Rake::Task["pl:remote:dmg"].execute if Pkg::Config.build_dmg
       Rake::Task["package:tar"].execute
       Rake::Task["pl:sign_tar"].invoke
       Rake::Task["pl:uber_ship"].execute
@@ -132,10 +132,10 @@ if File.exist?("#{ENV['HOME']}/.packaging")
 
     task :uber_final do
       deprecate("pl:uber_final", "pl:uber_release")
-      Rake::Task["package:gem"].invoke if @build.build_gem
+      Rake::Task["package:gem"].invoke if Pkg::Config.build_gem
       Rake::Task["pl:remote_deb_final"].invoke
       Rake::Task["pl:remote_rpm_final"].execute
-      Rake::Task["pl:remote:dmg"].execute if @build.build_dmg
+      Rake::Task["pl:remote:dmg"].execute if Pkg::Config.build_dmg
       Rake::Task["package:tar"].execute
       Rake::Task["pl:sign_tar"].invoke
       Rake::Task["pl:uber_ship"].execute
@@ -144,10 +144,10 @@ if File.exist?("#{ENV['HOME']}/.packaging")
     end
 
     task :uber_release do
-      Rake::Task["package:gem"].invoke if @build.build_gem
+      Rake::Task["package:gem"].invoke if Pkg::Config.build_gem
       Rake::Task["pl:remote:release_deb"].invoke
       Rake::Task["pl:remote:release_rpm"].execute
-      Rake::Task["pl:remote:dmg"].execute if @build.build_dmg
+      Rake::Task["pl:remote:dmg"].execute if Pkg::Config.build_dmg
       Rake::Task["package:tar"].execute
       Rake::Task["pl:sign_tar"].invoke
       Rake::Task["pl:uber_ship"].execute

data/ext/packaging/tasks/retrieve.rake

@@ -16,13 +16,13 @@ namespace :pl do
       target = args.target || "artifacts"
       invoke_task("pl:fetch")
       mkdir_p 'pkg'
-      package_url = "http://#{@build.builds_server}/#{@build.project}/#{@build.ref}/#{target}"
-      if wget=find_tool("wget")
+      package_url = "http://#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{target}"
+      if wget=Pkg::Util::Tool.find_tool("wget")
         sh "#{wget} -r -np -nH --cut-dirs 3 -P pkg --reject 'index*' #{package_url}/"
       else
-        warn "Could not find `wget` tool. Falling back to rsyncing from #{@build.distribution_server}"
+        warn "Could not find `wget` tool. Falling back to rsyncing from #{Pkg::Config.distribution_server}"
         begin
-          rsync_from("#{@build.jenkins_repo_path}/#{@build.project}/#{@build.ref}/#{target}/", @build.distribution_server, "pkg/")
+          rsync_from("#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{target}/", Pkg::Config.distribution_server, "pkg/")
         rescue
           fail "Couldn't download packages from distribution server. Try installing wget!"
         end
@@ -32,7 +32,7 @@ namespace :pl do
   end
 end
 
-if @build.build_pe
+if Pkg::Config.build_pe
   namespace :pe do
     namespace :jenkins do
       desc "Retrieve packages from the distribution server\. Check out commit to retrieve"

data/ext/packaging/tasks/rpm.rake

@@ -1,15 +1,32 @@
 def prep_rpm_build_dir
-  temp = get_temp
-  mkdir_pr temp, "#{temp}/SOURCES", "#{temp}/SPECS"
-  cp_pr FileList["pkg/#{@build.project}-#{@build.version}.tar.gz*"], "#{temp}/SOURCES"
-  erb "ext/redhat/#{@build.project}.spec.erb", "#{temp}/SPECS/#{@build.project}.spec"
+  temp = Pkg::Util::File.mktemp
+  tarball = "#{Pkg::Config.project}-#{Pkg::Config.version}.tar.gz"
+  FileUtils.mkdir_p([temp, "#{temp}/SOURCES", "#{temp}/SPECS"])
+  cp_pr FileList["pkg/#{tarball}*"], "#{temp}/SOURCES"
+  # If the file ext/redhat/<project>.spec exists in the tarball, we use it. If
+  # it doesn't we try to 'erb' the file from a predicted template in source,
+  # ext/redhat/<project>.spec.erb. If that doesn't exist, we fail. To do this,
+  # we have to open the tarball.
+  cp_p("pkg/#{tarball}", temp)
+
+  # Test for specfile in tarball
+  %x{tar -tzf #{File.join(temp, tarball)}}.split.grep(/ext\/redhat\/#{Pkg::Config.project}.spec$/)
+
+  if $?.success?
+    sh "tar -C #{temp} -xzf #{File.join(temp, tarball)} #{Pkg::Config.project}-#{Pkg::Config.version}/ext/redhat/#{Pkg::Config.project}.spec"
+    cp("#{temp}/#{Pkg::Config.project}-#{Pkg::Config.version}/ext/redhat/#{Pkg::Config.project}.spec", "#{temp}/SPECS/")
+  elsif File.exists?("ext/redhat/#{Pkg::Config.project}.spec.erb")
+    Pkg::Util::File.erb_file("ext/redhat/#{Pkg::Config.project}.spec.erb", "#{temp}/SPECS/#{Pkg::Config.project}.spec", nil, :binding => Pkg::Config.get_binding)
+  else
+    fail "Could not locate redhat spec ext/redhat/#{Pkg::Config.project}.spec or ext/redhat/#{Pkg::Config.project}.spec.erb"
+  end
   temp
 end
 
 def build_rpm(buildarg = "-bs")
-  check_tool('rpmbuild')
+  Pkg::Util::Tool.check_tool('rpmbuild')
   workdir = prep_rpm_build_dir
-  if dist = el_version
+  if dist = Pkg::Util::Version.el_version
     if dist.to_i < 6
       dist_string = "--define \"%dist .el#{dist}"
     end
@@ -19,14 +36,14 @@ def build_rpm(buildarg = "-bs")
      --define "_binary_payload w9.gzdio" --define "_source_payload w9.gzdio" \
      --define "_default_patch_fuzz 2"'
   args = rpm_define + ' ' + rpm_old_version
-  mkdir_pr 'pkg/srpm'
+  FileUtils.mkdir_p('pkg/srpm')
   if buildarg == '-ba'
-    mkdir_p 'pkg/rpm'
+    FileUtils.mkdir_p('pkg/rpm')
   end
-  if @build.sign_tar
+  if Pkg::Config.sign_tar
     Rake::Task["pl:sign_tar"].invoke
   end
-  sh "rpmbuild #{args} #{buildarg} --nodeps #{workdir}/SPECS/#{@build.project}.spec"
+  sh "rpmbuild #{args} #{buildarg} --nodeps #{workdir}/SPECS/#{Pkg::Config.project}.spec"
   mv FileList["#{workdir}/SRPMS/*.rpm"], "pkg/srpm"
   if buildarg == '-ba'
     mv FileList["#{workdir}/RPMS/*/*.rpm"], "pkg/rpm"

data/ext/packaging/tasks/rpm_repos.rake

@@ -17,7 +17,7 @@ namespace :pl do
         # Formulate our command string, which will just find directories with rpms
         # and create and update repositories.
         #
-        artifact_directory = File.join(@build.jenkins_repo_path, @build.project, @build.ref)
+        artifact_directory = File.join(Pkg::Config.jenkins_repo_path, Pkg::Config.project, Pkg::Config.ref)
 
         ##
         # Test that the artifacts directory exists on the distribution server.
@@ -37,10 +37,11 @@ namespace :pl do
         cmd << "rsync -avxl artifacts/ repos/ ; pushd repos ; "
         cmd << "createrepo=$(which createrepo) ; "
         cmd << 'for repodir in $(find ./ -name "*.rpm" | xargs -I {} dirname {}) ; do '
-        cmd << "pushd $repodir && $createrepo -d --update . && popd ; "
+        cmd << "[ -d ${repodir} ] || continue; "
+        cmd << "pushd ${repodir} && ${createrepo} --checksum=sha --database --update . ; popd ; "
         cmd << "done ; popd "
 
-        remote_ssh_cmd(@build.distribution_server, cmd)
+        remote_ssh_cmd(Pkg::Config.distribution_server, cmd)
         # Now that we've created our repositories, we can create the configs for
         # them
         Rake::Task["pl:jenkins:generate_rpm_repo_configs"].execute
@@ -49,7 +50,7 @@ namespace :pl do
         Rake::Task["pl:jenkins:ship_repo_configs"].execute
       ensure
         # Always remove the lock file, even if we've failed
-        remote_ssh_cmd(@build.distribution_server, "rm -f #{artifact_directory}/.lock")
+        remote_ssh_cmd(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/.lock")
       end
     end
 
@@ -66,12 +67,12 @@ namespace :pl do
       # We have a hard requirement on wget because of all the download magicks
       # we have to do
       #
-      wget = find_tool("wget") or fail "Could not find `wget` tool. This is needed for composing the yum repo configurations. Install `wget` and try again."
+      wget = Pkg::Util::Tool.find_tool("wget") or fail "Could not find `wget` tool. This is needed for composing the yum repo configurations. Install `wget` and try again."
 
       # This is the standard path to all build artifacts on the distribution
       # server for this commit
       #
-      base_url = "http://#{@build.builds_server}/#{@build.project}/#{@build.ref}/repos/"
+      base_url = "http://#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repos/"
 
       # First check if the artifacts directory exists
       #
@@ -109,25 +110,25 @@ namespace :pl do
 
         # Create an array of lines that will become our yum config
         #
-        config = ["[pl-#{@build.project}-#{@build.ref}]"]
-        config << ["name=PL Repo for #{@build.project} at commit #{@build.ref}"]
+        config = ["[pl-#{Pkg::Config.project}-#{Pkg::Config.ref}]"]
+        config << ["name=PL Repo for #{Pkg::Config.project} at commit #{Pkg::Config.ref}"]
         config << ["baseurl=#{url}"]
         config << ["enabled=1"]
         config << ["gpgcheck=0"]
 
         # Write the new config to a file under our repo configs dir
         #
-        config_file = File.join("pkg", "repo_configs", "rpm", "pl-#{@build.project}-#{@build.ref}-#{dist}-#{version}-#{arch}.repo")
+        config_file = File.join("pkg", "repo_configs", "rpm", "pl-#{Pkg::Config.project}-#{Pkg::Config.ref}-#{dist}-#{version}-#{arch}.repo")
         File.open(config_file, 'w') { |f| f.puts config }
       end
-      puts "Wrote yum configuration files for #{@build.project} at #{@build.ref} to pkg/repo_configs/rpm"
+      puts "Wrote yum configuration files for #{Pkg::Config.project} at #{Pkg::Config.ref} to pkg/repo_configs/rpm"
     end
 
     desc "Retrieve rpm yum repository configs from distribution server"
     task :rpm_repo_configs => "pl:fetch" do
-      wget = find_tool("wget") or fail "Could not find `wget` tool! wget is required to download the repository configs."
+      wget = Pkg::Util::Tool.find_tool("wget") or fail "Could not find `wget` tool! wget is required to download the repository configs."
       mkdir_p "pkg/repo_configs"
-      config_url = "#{@build.builds_server}/#{@build.project}/#{@build.ref}/repo_configs/rpm/"
+      config_url = "#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repo_configs/rpm/"
       begin
         sh "#{wget} -r -np -nH --cut-dirs 3 -P pkg/repo_configs --reject 'index*' #{config_url}"
       rescue

data/ext/packaging/tasks/ship.rake

@@ -1,46 +1,46 @@
 namespace :pl do
-  desc "Ship mocked rpms to #{@build.yum_host}"
+  desc "Ship mocked rpms to #{Pkg::Config.yum_host}"
   task :ship_rpms do
     ["el", "fedora"].each do |dist|
       retry_on_fail(:times => 3) do
-        pkgs = Dir["pkg/#{dist}/**/*.rpm"].map { |f| "'#{f.gsub("pkg/#{dist}/", "#{@build.yum_repo_path}/#{dist}/")}'"}
+        pkgs = Dir["pkg/#{dist}/**/*.rpm"].map { |f| "'#{f.gsub("pkg/#{dist}/", "#{Pkg::Config.yum_repo_path}/#{dist}/")}'"}
         unless pkgs.empty?
-          rsync_to("pkg/#{dist}", @build.yum_host, @build.yum_repo_path)
-          remote_set_immutable(@build.yum_host, pkgs)
+          rsync_to("pkg/#{dist}", Pkg::Config.yum_host, Pkg::Config.yum_repo_path)
+          remote_set_immutable(Pkg::Config.yum_host, pkgs)
         end
       end if File.directory?("pkg/#{dist}")
     end
   end
 
   namespace :remote do
-    # These hacky bits execute a pre-existing rake task on the @build.apt_host
+    # These hacky bits execute a pre-existing rake task on the Pkg::Config.apt_host
     # The rake task takes packages in a specific directory and freights them
     # to various target yum and apt repositories based on their specific type
     # e.g., final vs devel vs PE vs FOSS packages
 
-    desc "Update remote rpm repodata on #{@build.yum_host}"
+    desc "Update remote rpm repodata on #{Pkg::Config.yum_host}"
     task :update_yum_repo do
-      STDOUT.puts "Really run remote repo update on #{@build.yum_host}? [y,n]"
+      STDOUT.puts "Really run remote repo update on #{Pkg::Config.yum_host}? [y,n]"
       if ask_yes_or_no
-        remote_ssh_cmd(@build.yum_host, 'rake -f /opt/repository/Rakefile mk_repo')
+        remote_ssh_cmd(Pkg::Config.yum_host, 'rake -f /opt/repository/Rakefile mk_repo')
       end
     end
 
-    desc "remote freight packages to repos on #{@build.apt_host}"
+    desc "remote freight packages to repos on #{Pkg::Config.apt_host}"
     task :freight do
-      STDOUT.puts "Really run remote freight command on #{@build.apt_host}? [y,n]"
+      STDOUT.puts "Really run remote freight command on #{Pkg::Config.apt_host}? [y,n]"
       if ask_yes_or_no
         override = "OVERRIDE=1" if ENV['OVERRIDE']
-        remote_ssh_cmd(@build.apt_host, "rake -f /opt/repository/Rakefile freight #{override}")
+        remote_ssh_cmd(Pkg::Config.apt_host, "rake -f /opt/repository/Rakefile freight #{override}")
       end
     end
   end
 
-  desc "Ship cow-built debs to #{@build.apt_host}"
+  desc "Ship cow-built debs to #{Pkg::Config.apt_host}"
   task :ship_debs do
     retry_on_fail(:times => 3) do
       if File.directory?("pkg/deb")
-        rsync_to('pkg/deb/', @build.apt_host, @build.apt_repo_path)
+        rsync_to('pkg/deb/', Pkg::Config.apt_host, Pkg::Config.apt_repo_path)
       end
     end
   end
@@ -48,32 +48,32 @@ namespace :pl do
   namespace :remote do
   end
 
-  desc "Update remote ips repository on #{@build.ips_host}"
+  desc "Update remote ips repository on #{Pkg::Config.ips_host}"
   task :update_ips_repo do
-    rsync_to('pkg/ips/pkgs/', @build.ips_host, @build.ips_store)
-    remote_ssh_cmd(@build.ips_host, "pkgrecv -s #{@build.ips_store}/pkgs/#{@build.project}@build.#{@build.ipsversion}.p5p -d #{@build.ips_repo} \\*")
-    remote_ssh_cmd(@build.ips_host, "pkgrepo refresh -s #{@build.ips_repo}")
-    remote_ssh_cmd(@build.ips_host, "/usr/sbin/svcadm restart svc:/application/pkg/server")
-  end if @build.build_ips
+    rsync_to('pkg/ips/pkgs/', Pkg::Config.ips_host, Pkg::Config.ips_store)
+    remote_ssh_cmd(Pkg::Config.ips_host, "pkgrecv -s #{Pkg::Config.ips_store}/pkgs/#{Pkg::Config.project}Pkg::Config.#{Pkg::Config.ipsversion}.p5p -d #{Pkg::Config.ips_repo} \\*")
+    remote_ssh_cmd(Pkg::Config.ips_host, "pkgrepo refresh -s #{Pkg::Config.ips_repo}")
+    remote_ssh_cmd(Pkg::Config.ips_host, "/usr/sbin/svcadm restart svc:/application/pkg/server")
+  end if Pkg::Config.build_ips
 
   desc "Upload ips p5p packages to downloads"
   task :ship_ips => 'pl:fetch' do
     if Dir['pkg/ips/pkgs/**/*'].empty?
       STDOUT.puts "There aren't any p5p packages in pkg/ips/pkgs. Maybe something went wrong?"
     else
-      rsync_to('pkg/ips/pkgs/', @build.ips_package_host, @build.ips_path)
+      rsync_to('pkg/ips/pkgs/', Pkg::Config.ips_package_host, Pkg::Config.ips_path)
     end
-  end if @build.build_ips
+  end if Pkg::Config.build_ips
 
   # We want to ship a gem only for projects that build gems
-  if @build.build_gem
+  if Pkg::Config.build_gem
     desc "Ship built gem to rubygems"
     task :ship_gem do
-      # Even if a project builds a gem, if it uses the odd_even strategy, we only
-      # want to ship final gems because otherwise a development gem would be
-      # preferred over the last final gem
-      if @build.version_strategy != "odd_even" || is_final?
-        FileList["pkg/#{@build.project}-#{@build.gemversion}*.gem"].each do |f|
+      # Even if a project builds a gem, if it uses the odd_even or zero-based
+      # strategies, we only want to ship final gems because otherwise a
+      # development gem would be preferred over the last final gem
+      if Pkg::Config.version_strategy !~ /odd_even|zero_based/ || Pkg::Util::Version.is_final?
+        FileList["pkg/#{Pkg::Config.gem_name}-#{Pkg::Config.gemversion}*.gem"].each do |f|
           puts "Shipping gem #{f} to rubygems"
           ship_gem(f)
         end
@@ -83,17 +83,17 @@ namespace :pl do
     end
   end
 
-  desc "ship apple dmg to #{@build.yum_host}"
+  desc "ship apple dmg to #{Pkg::Config.yum_host}"
   task :ship_dmg => 'pl:fetch' do
     retry_on_fail(:times => 3) do
-      rsync_to('pkg/apple/*.dmg', @build.yum_host, @build.dmg_path)
+      rsync_to('pkg/apple/*.dmg', Pkg::Config.yum_host, Pkg::Config.dmg_path)
     end
-  end if @build.build_dmg
+  end if Pkg::Config.build_dmg
 
-  desc "ship tarball and signature to #{@build.tar_host}"
+  desc "ship tarball and signature to #{Pkg::Config.tar_host}"
   task :ship_tar => 'pl:fetch' do
     retry_on_fail(:times => 3) do
-      rsync_to("pkg/#{@build.project}-#{@build.version}.tar.gz*", @build.tar_host, @build.tarball_path)
+      rsync_to("pkg/#{Pkg::Config.project}-#{Pkg::Config.version}.tar.gz*", Pkg::Config.tar_host, Pkg::Config.tarball_path)
     end
   end
 
@@ -101,14 +101,14 @@ namespace :pl do
   task :uber_ship => 'pl:fetch' do
     if confirm_ship(FileList["pkg/**/*"])
       ENV['ANSWER_OVERRIDE'] = 'yes'
-      Rake::Task["pl:ship_gem"].invoke if @build.build_gem
+      Rake::Task["pl:ship_gem"].invoke if Pkg::Config.build_gem
       Rake::Task["pl:ship_rpms"].invoke
       Rake::Task["pl:ship_debs"].invoke
-      Rake::Task["pl:ship_dmg"].execute if @build.build_dmg
+      Rake::Task["pl:ship_dmg"].execute if Pkg::Config.build_dmg
       Rake::Task["pl:ship_tar"].execute
       Rake::Task["pl:jenkins:ship"].invoke("shipped")
-      add_shipped_metrics(:pe_version => ENV['PE_VER'], :is_rc => (! is_final?)) if @build.benchmark
-      post_shipped_metrics if @build.benchmark
+      add_shipped_metrics(:pe_version => ENV['PE_VER'], :is_rc => (! Pkg::Util::Version.is_final?)) if Pkg::Config.benchmark
+      post_shipped_metrics if Pkg::Config.benchmark
     else
       puts "Ship canceled"
       exit
@@ -126,12 +126,12 @@ namespace :pl do
     task :ship, :target do |t, args|
       invoke_task("pl:fetch")
       target = args.target || "artifacts"
-      artifact_dir = "#{@build.jenkins_repo_path}/#{@build.project}/#{@build.ref}/#{target}"
+      artifact_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{target}"
 
       # In order to get a snapshot of what this build looked like at the time
       # of shipping, we also generate and ship the params file
       #
-      @build.params_to_yaml('pkg')
+      Pkg::Config.config_to_yaml('pkg')
 
 
       # Sadly, the packaging repo cannot yet act on its own, without living
@@ -141,28 +141,50 @@ namespace :pl do
       # clone itself.
       git_bundle('HEAD', 'signing_bundle', 'pkg')
 
+      # While we're bundling things, let's also make a git bundle of the
+      # packaging repo that we're using when we invoke pl:jenkins:ship. We can
+      # have a reasonable level of confidence, later on, that the git bundle on
+      # the distribution server was, in fact, the git bundle used to create the
+      # associated packages. This is because this ship task is automatically
+      # called upon completion each cell of the pl:jenkins:uber_build, and we
+      # have --ignore-existing set below. As such, the only git bundle that
+      # should possibly be on the distribution is the one used to create the
+      # packages.
+      # We're bundling the packaging repo because it allows us to keep an
+      # archive of the packaging source that was used to create the packages,
+      # so that later on if we need to rebuild an older package to audit it or
+      # for some other reason we're assured that the new package isn't
+      # different by virtue of the packaging automation.
+      if defined?(PACKAGING_ROOT)
+        packaging_bundle = ''
+        cd PACKAGING_ROOT do
+          packaging_bundle = git_bundle('HEAD', 'packaging-bundle')
+        end
+        mv(packaging_bundle, 'pkg')
+      end
+
       retry_on_fail(:times => 3) do
-        remote_ssh_cmd(@build.distribution_server, "mkdir -p #{artifact_dir}")
+        remote_ssh_cmd(Pkg::Config.distribution_server, "mkdir -p #{artifact_dir}")
       end
       retry_on_fail(:times => 3) do
         ignore_existing = "--ignore-existing"
-        rsync_to("pkg/", @build.distribution_server, "#{artifact_dir}/ #{ignore_existing} --exclude repo_configs")
+        rsync_to("pkg/", Pkg::Config.distribution_server, "#{artifact_dir}/ #{ignore_existing} --exclude repo_configs")
       end
       # If we just shipped a tagged version, we want to make it immutable
       files = Dir.glob("pkg/**/*").select { |f| File.file?(f) }.map do |file|
         "#{artifact_dir}/#{file.sub(/^pkg\//,'')}"
       end
-      remote_set_immutable(@build.distribution_server, files)
+      remote_set_immutable(Pkg::Config.distribution_server, files)
     end
 
     desc "Ship generated repository configs to the distribution server"
     task :ship_repo_configs do
-      empty_dir?("pkg/repo_configs") and fail "No repo configs have been generated! Try pl:deb_repo_configs or pl:rpm_repo_configs"
+      Pkg::Util::File.empty_dir?("pkg/repo_configs") and fail "No repo configs have been generated! Try pl:deb_repo_configs or pl:rpm_repo_configs"
       invoke_task("pl:fetch")
-      repo_dir = "#{@build.jenkins_repo_path}/#{@build.project}/#{@build.ref}/repo_configs"
-      remote_ssh_cmd(@build.distribution_server, "mkdir -p #{repo_dir}")
+      repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repo_configs"
+      remote_ssh_cmd(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
       retry_on_fail(:times => 3) do
-        rsync_to("pkg/repo_configs/", @build.distribution_server, repo_dir)
+        rsync_to("pkg/repo_configs/", Pkg::Config.distribution_server, repo_dir)
       end
     end
   end