puppet 2.7.25 → 2.7.26

data/ext/packaging/tasks/doc.rake

@@ -1,7 +1,7 @@
 # Most projects set rdoc options in the context of gem building. However, mcollective
-# generates its own rdoc package. We can reuse the @build.gem_rdoc_options here
+# generates its own rdoc package. We can reuse the Pkg::Config.gem_rdoc_options here
 
-if @build.build_doc
+if Pkg::Config.build_doc
   begin
     require 'rdoc/task'
   rescue LoadError
@@ -11,10 +11,10 @@ if @build.build_doc
   namespace :package do
     RDoc::Task.new(:doc) do |rdoc|
       rdoc.rdoc_dir = 'doc'
-      rdoc.title = "#{@build.project} version #{@build.version}"
-      @build.gem_rdoc_options.each do |option|
+      rdoc.title = "#{Pkg::Config.project} version #{Pkg::Config.version}"
+      Pkg::Config.gem_rdoc_options.each do |option|
         rdoc.options << option
-      end unless @build.gem_rdoc_options.nil?
+      end unless Pkg::Config.gem_rdoc_options.nil?
     end
   end
 end

data/ext/packaging/tasks/fetch.rake

@@ -4,11 +4,11 @@
 # also has a data file for information specific to it. If the project builds
 # both PE and not PE, it has two files, one for PE, and the other for FOSS
 #
-data_repo = 'https://raw.github.com/puppetlabs/build-data'
-project_data_branch = @build.project
-team_data_branch = @build.team
+data_repo = 'https://raw.githubusercontent.com/puppetlabs/build-data'
+project_data_branch = Pkg::Config.project
+team_data_branch = Pkg::Config.team
 
-if @build.build_pe
+if Pkg::Config.build_pe
   project_data_branch = 'pe-' + project_data_branch unless project_data_branch =~ /^pe-/
   team_data_branch = 'pe-' + team_data_branch unless team_data_branch =~ /^pe-/
 end
@@ -22,22 +22,22 @@ team_data_url = data_repo + '/' + team_data_branch
 # defaults specified in the source project repo, e.g. in ext/build_defaults.yaml
 #
 # It uses curl to download the files, and places them in a temporary
-# directory, e.g. /tmp/somedirectory/{project,team}/@build.builder_data_file
+# directory, e.g. /tmp/somedirectory/{project,team}/Pkg::Config.builder_data_file
 namespace :pl do
   task :fetch do
     # Remove .packaging directory from old-style extras loading
     rm_rf "#{ENV['HOME']}/.packaging" if File.directory?("#{ENV['HOME']}/.packaging")
     # Touch the .packaging file which is allows packaging to present remote tasks
     touch "#{ENV['HOME']}/.packaging"
-    if dist = el_version
+    if dist = Pkg::Util::Version.el_version
       if dist.to_i < 6
         flag = "-k"
       end
     end
     [project_data_url, team_data_url].each do |url|
       begin
-        tempdir = get_temp
-        %x{curl --fail --silent #{flag} #{url}/#{@build.builder_data_file} > #{tempdir}/#{@build.builder_data_file}}
+        tempdir = Pkg::Util::File.mktemp
+        %x{curl --fail --silent #{flag} #{url}/#{Pkg::Config.builder_data_file} > #{tempdir}/#{Pkg::Config.builder_data_file}}
         case $?.exitstatus
         when 0
           invoke_task("pl:load_extras", tempdir)
@@ -45,7 +45,7 @@ namespace :pl do
           if url == team_data_url
             fail "Could not load team extras data from #{url}. This should not normally happen"
           else
-            puts "No build data file for #{@build.project}, skipping load of extra build data."
+            puts "No build data file for #{Pkg::Config.project}, skipping load of extra build data."
           end
         else
           fail "There was an error fetching the builder extras data from #{url}."

data/ext/packaging/tasks/gem.rake

@@ -1,10 +1,10 @@
-if @build.build_gem
+if Pkg::Config.build_gem
   require 'rubygems/package_task'
 
   def glob_gem_files
     gem_files = []
     gem_excludes_file_list = []
-    gem_excludes_raw = @build.gem_excludes.nil? ? [] : @build.gem_excludes.split(' ')
+    gem_excludes_raw = Pkg::Config.gem_excludes.nil? ? [] : Pkg::Config.gem_excludes.split(' ')
     gem_excludes_raw << 'ext/packaging'
     gem_excludes_raw.each do |exclude|
       if File.directory?(exclude)
@@ -13,7 +13,7 @@ if @build.build_gem
         gem_excludes_file_list << exclude
       end
     end
-    files = FileList[@build.gem_files.split(' ')]
+    files = FileList[Pkg::Config.gem_files.split(' ')]
     files.each do |file|
       if File.directory?(file)
         gem_files += FileList["#{file}/**/*"]
@@ -39,50 +39,75 @@ if @build.build_gem
 
   def create_default_gem_spec
     spec = Gem::Specification.new do |s|
-      s.name = @build.project                                     unless @build.project.nil?
-      s.name = @build.gem_name                                    unless @build.gem_name.nil?
-      s.version = @build.gemversion                               unless @build.gemversion.nil?
-      s.author = @build.author                                    unless @build.author.nil?
-      s.email = @build.email                                      unless @build.email.nil?
-      s.homepage = @build.homepage                                unless @build.homepage.nil?
-      s.summary = @build.summary                                  unless @build.summary.nil?
-      s.summary = @build.gem_summary                              unless @build.gem_summary.nil?
-      s.description = @build.description                          unless @build.description.nil?
-      s.description = @build.gem_description                      unless @build.gem_description.nil?
-      s.files = glob_gem_files                                    unless glob_gem_files.nil?
-      s.executables = @build.gem_executables                      unless @build.gem_executables.nil?
-      s.require_path = @build.gem_require_path                    unless @build.gem_require_path.nil?
-      s.test_files = FileList[@build.gem_test_files.split(' ')]   unless @build.gem_test_files.nil?
-      s.rubyforge_project = @build.gem_forge_project              unless @build.gem_forge_project.nil?
-      @build.gem_rdoc_options.each do |option|
+      s.name = Pkg::Config.project                                     unless Pkg::Config.project.nil?
+      s.name = Pkg::Config.gem_name                                    unless Pkg::Config.gem_name.nil?
+      s.version = Pkg::Config.gemversion                               unless Pkg::Config.gemversion.nil?
+      s.author = Pkg::Config.author                                    unless Pkg::Config.author.nil?
+      s.email = Pkg::Config.email                                      unless Pkg::Config.email.nil?
+      s.homepage = Pkg::Config.homepage                                unless Pkg::Config.homepage.nil?
+      s.summary = Pkg::Config.summary                                  unless Pkg::Config.summary.nil?
+      s.summary = Pkg::Config.gem_summary                              unless Pkg::Config.gem_summary.nil?
+      s.description = Pkg::Config.description                          unless Pkg::Config.description.nil?
+      s.description = Pkg::Config.gem_description                      unless Pkg::Config.gem_description.nil?
+      s.files = glob_gem_files                                         unless glob_gem_files.nil?
+      s.executables = Pkg::Config.gem_executables                      unless Pkg::Config.gem_executables.nil?
+      s.require_path = Pkg::Config.gem_require_path                    unless Pkg::Config.gem_require_path.nil?
+      s.test_files = FileList[Pkg::Config.gem_test_files.split(' ')]   unless Pkg::Config.gem_test_files.nil?
+      s.rubyforge_project = Pkg::Config.gem_forge_project              unless Pkg::Config.gem_forge_project.nil?
+      Pkg::Config.gem_rdoc_options.each do |option|
         s.rdoc_options << option
-      end unless @build.gem_rdoc_options.nil?
+      end unless Pkg::Config.gem_rdoc_options.nil?
     end
 
-    @build.gem_runtime_dependencies.each do |gem, version|
+    Pkg::Config.gem_runtime_dependencies.each do |gem, version|
       spec = add_gem_dependency(:spec => spec, :gem => gem, :version => version, :type => :runtime)
-    end unless @build.gem_runtime_dependencies.nil?
+    end unless Pkg::Config.gem_runtime_dependencies.nil?
 
-    @build.gem_development_dependencies.each do |gem, version|
+    Pkg::Config.gem_development_dependencies.each do |gem, version|
       spec = add_gem_dependency(:spec => spec, :gem => gem, :version => version, :type => :development)
-    end unless @build.gem_development_dependencies.nil?
+    end unless Pkg::Config.gem_development_dependencies.nil?
     spec
   end
 
+  def copy_gem_files_into(workdir)
+    # Take all of the gem files (both test and lib), and copy them into the workdir
+    (glob_gem_files + FileList[(Pkg::Config.gem_test_files || '').split(' ')]).each do |file|
+      if File.directory?(file)
+        mkpath(File.join(workdir, file))
+      else
+        mkpath(File.dirname( File.join(workdir, file) ), :verbose => false)
+        cp(file, File.join(workdir, file), :verbose => true, :preserve => false)
+      end
+    end
+  end
+
   def create_gem(spec, gembuilddir)
-    gem_task = Gem::PackageTask.new(spec)
+    workdir = File.join(Pkg::Util::File.mktemp)
+    mkpath workdir
+
     bench = Benchmark.realtime do
-      gem_task.define
-      Rake::Task[:gem].reenable
-      Rake::Task[:gem].invoke
-      rm_r File.join("pkg", gembuilddir)
+      copy_gem_files_into(workdir)
+
+      # Burn in the version for the project if needed
+      Pkg::Util::Version.versionbump(workdir) if Pkg::Config.update_version_file
+
+      cd workdir do
+        gem_task = Gem::PackageTask.new(spec)
+        gem_task.define
+        Rake::Task[:gem].reenable
+        Rake::Task[:gem].invoke
+        rm_rf File.join("pkg", gembuilddir)
+        mv Dir.glob("pkg/#{Pkg::Config.gem_name}-#{Pkg::Config.gemversion}*.gem"), File.join(Pkg::Config.project_root, "pkg")
+      end
     end
+
+    rm_rf workdir
     puts "Finished building in: #{bench}"
   end
 
   def create_default_gem
     spec = create_default_gem_spec
-    create_gem(spec, "#{@build.project}-#{@build.gemversion}")
+    create_gem(spec, "#{Pkg::Config.gem_name}-#{Pkg::Config.gemversion}")
   end
 
   def unknown_gems_platform?(platform)
@@ -91,7 +116,7 @@ if @build.build_gem
   end
 
   def create_platform_specific_gems
-    @build.gem_platform_dependencies.each do |platform, dependency_hash|
+    Pkg::Config.gem_platform_dependencies.each do |platform, dependency_hash|
       spec = create_default_gem_spec
       pf = Gem::Platform.new(platform)
       fail "
@@ -111,15 +136,16 @@ if @build.build_gem
           spec = add_gem_dependency(:spec => spec, :gem => gem, :version => version, :type => t)
         end
       end
-      create_gem(spec, "#{@build.project}-#{@build.gemversion}-#{platform}")
+      create_gem(spec, "#{Pkg::Config.gem_name}-#{Pkg::Config.gemversion}-#{platform}")
     end
   end
 
   namespace :package do
     desc "Build a gem - All gems if platform specific"
     task :gem => [ "clean" ] do
+      mkdir_p File.join(Pkg::Config.project_root, "pkg")
       create_default_gem
-      if @build.gem_platform_dependencies
+      if Pkg::Config.gem_platform_dependencies
         create_platform_specific_gems
       end
     end

data/ext/packaging/tasks/ips.rake

@@ -1,5 +1,4 @@
 if @build_ips
-  require 'erb'
   namespace :package do
     namespace :ips do
       workdir = "pkg/ips/workdir"
@@ -7,7 +6,7 @@ if @build_ips
       repo = workdir + '/repo'
       pkgs = 'pkg/ips/pkgs'
       repouri = 'file://' + Dir.pwd + '/' + repo
-      artifact = pkgs + "/#{@build.project}@#{@build.ipsversion}.p5p"
+      artifact = pkgs + "/#{Pkg::Config.project}@#{Pkg::Config.ipsversion}.p5p"
 
       # Create a source repo
       # We dont clean the base pkg directory only ips work dir.
@@ -21,40 +20,40 @@ if @build_ips
 
       # Create an installation image at ips/proto
       task :prepare do
-        mkdir_pr workdir, pkgs
+        FileUtils.mkdir_p([workdir, pkgs])
         sh "gmake -f ext/ips/rules DESTDIR=#{proto} 2>#{workdir}/build.out"
       end
 
       # Process templates and write the initial manifest
       task :prototmpl do
-        erb("ext/ips/#{@build.project}.p5m.erb", workdir + '/' + @build.project + '.p5m.x')
+        Pkg::Util::File.erb_file("ext/ips/#{Pkg::Config.project}.p5m.erb", workdir + '/' + Pkg::Config.project + '.p5m.x', nil, :binding => Pkg::Config.get_binding)
       end
 
       # Update manifest to include the installation image information.
       task :protogen => :prototmpl do
-        sh "pkgsend generate #{proto} >> #{workdir}/#{@build.project}.p5m.x"
+        sh "pkgsend generate #{proto} >> #{workdir}/#{Pkg::Config.project}.p5m.x"
       end
 
       # Generate and resolve dependency list
       task :protodeps => :protogen do
-        sh "pkgdepend generate -d #{proto} #{workdir}/#{@build.project}.p5m.x > #{workdir}/#{@build.project}.depends"
-        sh "pkgdepend resolve -m #{workdir}/#{@build.project}.depends"
-        sh "cat #{workdir}/#{@build.project}.depends.res >> #{workdir}/#{@build.project}.p5m.x"
+        sh "pkgdepend generate -d #{proto} #{workdir}/#{Pkg::Config.project}.p5m.x > #{workdir}/#{Pkg::Config.project}.depends"
+        sh "pkgdepend resolve -m #{workdir}/#{Pkg::Config.project}.depends"
+        sh "cat #{workdir}/#{Pkg::Config.project}.depends.res >> #{workdir}/#{Pkg::Config.project}.p5m.x"
       end
 
       # Mogrify manifest to remove unncecessary info, and other kinds of transforms.
       task :protomogrify => :protodeps do
-        sh "pkgmogrify ./ext/ips/transforms ./#{workdir}/#{@build.project}.p5m.x| pkgfmt >> #{workdir}/#{@build.project}.p5m"
+        sh "pkgmogrify ./ext/ips/transforms ./#{workdir}/#{Pkg::Config.project}.p5m.x| pkgfmt >> #{workdir}/#{Pkg::Config.project}.p5m"
       end
 
       # Generate and resolve dependency list
       task :license => :protomogrify do
-        cp 'LICENSE', "#{proto}/#{@build.project}.license"
+        cp 'LICENSE', "#{proto}/#{Pkg::Config.project}.license"
       end
 
       # Ensure that our manifest is sane.
       task :lint => :license do
-        print %x{pkglint #{workdir}/#{@build.project}.p5m}
+        print %x{pkglint #{workdir}/#{Pkg::Config.project}.p5m}
       end
 
       task :package => [:clean_pkgs, :clean, :prepare, :lint] do
@@ -63,35 +62,35 @@ if @build_ips
 
       # Create a local file-based IPS repository
       task :createrepo do
-        check_tool('pkgrepo')
+        Pkg::Util::Tool.check_tool('pkgrepo')
         sh "pkgrepo create #{repo}"
         sh "pkgrepo set -s #{repo} publisher/prefix=puppetlabs.com"
       end
 
       # Send a created package to the local IPS repository
       task :send do
-        check_tool('pkgsend')
-        sh "pkgsend -s #{repouri} publish -d #{proto} --fmri-in-manifest #{workdir}/#{@build.project}.p5m"
+        Pkg::Util::Tool.check_tool('pkgsend')
+        sh "pkgsend -s #{repouri} publish -d #{proto} --fmri-in-manifest #{workdir}/#{Pkg::Config.project}.p5m"
       end
 
       # Retrieve the package from the remote repository in .p5p archive format
       task :receive do
-        check_tool('pkgrecv')
-        sh "pkgrecv -s #{repouri} -a -d #{artifact} #{@build.project}@#{@build.ipsversion}"
+        Pkg::Util::Tool.check_tool('pkgrecv')
+        sh "pkgrecv -s #{repouri} -a -d #{artifact} #{Pkg::Config.project}@#{Pkg::Config.ipsversion}"
       end
 
 
       task :dry_install do
-        sh "pkg install -nv -g #{artifact} #{@build.project}@#{@build.ipsversion}"
+        sh "pkg install -nv -g #{artifact} #{Pkg::Config.project}@#{Pkg::Config.ipsversion}"
       end
 
       task :p5p, :sign_ips do |t, args|
         # make sure our system dependencies are met
-        check_tool('pkg')
-        check_tool('pkgdepend')
-        check_tool('pkgsend')
-        check_tool('pkglint')
-        check_tool('pkgmogrify')
+        Pkg::Util::Tool.check_tool('pkg')
+        Pkg::Util::Tool.check_tool('pkgdepend')
+        Pkg::Util::Tool.check_tool('pkgsend')
+        Pkg::Util::Tool.check_tool('pkglint')
+        Pkg::Util::Tool.check_tool('pkgmogrify')
         sign_ips = args.sign_ips
         # create the package manifest & files (the "package")
         Rake::Task['package:ips:package'].invoke
@@ -100,7 +99,7 @@ if @build_ips
         # publish the package to the repository
         Rake::Task['package:ips:send'].invoke
         # signing the package occurs remotely in the repository
-        Rake::Task['pl:sign_ips'].invoke(repouri,"#{@build.project}@#{@build.ipsversion}") if sign_ips
+        Rake::Task['pl:sign_ips'].invoke(repouri,"#{Pkg::Config.project}@#{Pkg::Config.ipsversion}") if sign_ips
         # retrieve the signed package in a .p5p archive file format
         Rake::Task['package:ips:receive'].invoke
         # clean up the workdir area

data/ext/packaging/tasks/jenkins.rake

@@ -91,25 +91,25 @@ namespace :pl do
     #
     task :post_build, :build_task do |t, args|
       # Check for a dirty tree before allowing a remote build that is doomed to unexpected results
-      fail_on_dirty_source
+      Pkg::Util::Version.fail_on_dirty_source
 
       # We use JSON for parsing the json part of the submission to JSON
-      require_library_or_fail 'json'
+      Pkg::Util.require_library_or_fail 'json'
 
       build_task = args.build_task
       ##
-      # We set @:task of @build manually with our task data so the remote
+      # We set @:task of Pkg::Config manually with our task data so the remote
       # build knows what to do. Puppetdb needs early knowledge of if this is
       # a PE build, so we always this along as an environment variable task
       # argument if its the case.
       #
-      @build.task = { :task => "#{build_task}", :args => nil }
-      @build.task[:args] = ["PE_BUILD=true"] if @build_pe
+      Pkg::Config.task = { :task => "#{build_task}", :args => nil }
+      Pkg::Config.task[:args] = ["PE_BUILD=true"] if @build_pe
       #
       # Determine the type of build we're doing to inform jenkins
       build_type = case build_task
         when /deb/
-          if @build.default_cow.split('-')[1] =~ /cumulus/
+          if Pkg::Config.default_cow.split('-')[1] =~ /cumulus/
             "cumulus"
           else
             "deb"
@@ -123,12 +123,12 @@ namespace :pl do
 
       # Create a string of metrics to send to Jenkins for data analysis
       dist = case build_type
-        when /deb/ then @build.default_cow.split('-')[1]
+        when /deb/ then Pkg::Config.default_cow.split('-')[1]
         when /rpm/
-          if @build.pe_version
-            @build.final_mocks.split(' ')[0].split('-')[2]
+          if Pkg::Config.pe_version
+            Pkg::Config.final_mocks.split(' ')[0].split('-')[2]
           else
-            @build.final_mocks.split(' ')[0].split('-')[1..2].join("")
+            Pkg::Config.final_mocks.split(' ')[0].split('-')[1..2].join("")
           end
         when /dmg/ then "apple"
         when /gem/ then "gem"
@@ -137,20 +137,20 @@ namespace :pl do
         else raise "Could not determine build type for #{build_task}"
       end
 
-      if @build.pe_version
-        metrics = "#{ENV['USER']}~#{@build.version}~#{@build.pe_version}~#{dist}~#{@build.team}"
+      if Pkg::Config.pe_version
+        metrics = "#{ENV['USER']}~#{Pkg::Config.version}~#{Pkg::Config.pe_version}~#{dist}~#{Pkg::Config.team}"
       else
-        metrics = "#{ENV['USER']}~#{@build.version}~N/A~#{dist}~#{@build.team}"
+        metrics = "#{ENV['USER']}~#{Pkg::Config.version}~N/A~#{dist}~#{Pkg::Config.team}"
       end
       #
       # Create the data files to send to jenkins
-      properties = @build.params_to_yaml
+      properties = Pkg::Config.config_to_yaml
       bundle = git_bundle('HEAD')
 
       # 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" => "BUILD_TYPE",       "label" => "#{build_type}" },
                     { "name" => "METRICS",          "value" => "#{metrics}"}]
 
@@ -175,7 +175,7 @@ namespace :pl do
       args <<  [
       "-Fname=BUILD_PROPERTIES", "-Ffile0=@#{properties}",
       "-Fname=PROJECT_BUNDLE"  , "-Ffile1=@#{bundle}",
-      "-Fname=PROJECT"         , "-Fvalue=#{@build.project}",
+      "-Fname=PROJECT"         , "-Fvalue=#{Pkg::Config.project}",
       "-Fname=BUILD_TYPE"      , "-Fvalue=#{build_type}",
       "-Fname=METRICS"         , "-Fvalue=#{metrics}",
       "-FSubmit=Build",
@@ -187,7 +187,7 @@ namespace :pl do
 
       # Construct the job url
       #
-      job_url = "#{@build.jenkins_build_host}/job/#{@build.jenkins_packaging_job}"
+      job_url = "#{Pkg::Config.jenkins_build_host}/job/#{Pkg::Config.jenkins_packaging_job}"
       trigger_url = "#{job_url}/build"
 
       # Call out to the curl_form_data utility method in 00_utils.rake
@@ -195,7 +195,7 @@ namespace :pl do
       begin
         if curl_form_data(trigger_url, args)
           puts "Build submitted. To view your build results, go to #{job_url}"
-          puts "Your packages will be available at #{@build.distribution_server}:#{@build.jenkins_repo_path}/#{@build.project}/#{@build.ref}"
+          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
@@ -213,8 +213,8 @@ end
 # tasks. We can assume deb, mock, but not gem/dmg.
 #
 tasks = ["deb", "mock", "tar"]
-tasks << "gem" if @build.build_gem and ! @build.build_pe
-tasks << "dmg" if @build.build_dmg and ! @build.build_pe
+tasks << "gem" if Pkg::Config.build_gem and ! Pkg::Config.build_pe
+tasks << "dmg" if Pkg::Config.build_dmg and ! Pkg::Config.build_pe
 
 namespace :pl do
   namespace :jenkins do
@@ -231,8 +231,8 @@ namespace :pl do
     # DOSing it with our packaging.
     desc "Queue pl:deb_all on jenkins builder"
     task :deb_all => "pl:fetch" do
-      @build.cows.split(' ').each do |cow|
-        @build.default_cow = cow
+      Pkg::Config.cows.split(' ').each do |cow|
+        Pkg::Config.default_cow = cow
         invoke_task("pl:jenkins:post_build", "pl:deb")
         sleep 5
       end
@@ -241,8 +241,8 @@ namespace :pl do
     # This does the mocks in parallel
     desc "Queue pl:mock_all on jenkins builder"
     task :mock_all => "pl:fetch" do
-      @build.final_mocks.split(' ').each do |mock|
-        @build.default_mock = mock
+      Pkg::Config.final_mocks.split(' ').each do |mock|
+        Pkg::Config.default_mock = mock
         invoke_task("pl:jenkins:post_build", "pl:mock")
         sleep 5
       end
@@ -260,13 +260,13 @@ end
 ##
 # If this is a PE project, we want PE tasks as well.
 #
-if @build.build_pe
+if Pkg::Config.build_pe
   namespace :pe do
     namespace :jenkins do
       tasks.each do |build_task|
         desc "Queue pe:#{build_task} build on jenkins builder"
         task build_task => "pl:fetch" do
-          check_var("PE_VER", @build.pe_version)
+          check_var("PE_VER", Pkg::Config.pe_version)
           invoke_task("pl:jenkins:post_build", "pe:#{build_task}")
         end
       end
@@ -277,9 +277,9 @@ if @build.build_pe
       # DOSing it with our packaging.
       desc "Queue pe:deb_all on jenkins builder"
       task :deb_all => "pl:fetch" do
-        check_var("PE_VER", @build.pe_version)
-        @build.cows.split(' ').each do |cow|
-          @build.default_cow = cow
+        check_var("PE_VER", Pkg::Config.pe_version)
+        Pkg::Config.cows.split(' ').each do |cow|
+          Pkg::Config.default_cow = cow
           invoke_task("pl:jenkins:post_build", "pe:deb")
           sleep 5
         end
@@ -288,8 +288,8 @@ if @build.build_pe
       # This does the mocks in parallel
       desc "Queue pe:mock_all on jenkins builder"
       task :mock_all => "pl:fetch" do
-        @build.final_mocks.split(' ').each do |mock|
-          @build.default_mock = mock
+        Pkg::Config.final_mocks.split(' ').each do |mock|
+          Pkg::Config.default_mock = mock
           invoke_task("pl:jenkins:post_build", "pe:mock")
           sleep 5
         end
@@ -297,7 +297,7 @@ if @build.build_pe
 
       desc "Retrieve PE packages built by jenkins, sign, and ship all!"
       task :uber_ship => "pl:fetch" do
-        check_var("PE_VER", @build.pe_version)
+        check_var("PE_VER", Pkg::Config.pe_version)
         ["pl:jenkins:retrieve", "pl:jenkins:sign_all", "pe:ship_rpms", "pe:ship_debs"].each do |task|
           Rake::Task[task].invoke
         end
@@ -340,11 +340,11 @@ namespace :pl do
       end
 
       # Assemble the JSON string for the JSON parameter
-      json = JSON.generate("parameter" => [{ "name" => "SHA", "value"  => "#{@build.ref}" }])
+      json = JSON.generate("parameter" => [{ "name" => "SHA", "value"  => "#{Pkg::Config.ref}" }])
 
       # Assemble our arguments to the post
       args = [
-      "-Fname=SHA", "-Fvalue=#{@build.ref}",
+      "-Fname=SHA", "-Fvalue=#{Pkg::Config.ref}",
       "-Fjson=#{json.to_json}",
       "-FSubmit=Build"
       ]