puppet 2.7.20 → 2.7.21

data/ext/packaging/tasks/pe_sign.rake

@@ -1,27 +1,28 @@
 # The sign_el5 and sign_modern methods are defined in sign.rake
 # This is just adapted for the 'PE' layout
 
-namespace :pe do
-  desc "Sign all staged in rpms in pkg"
-  task :sign_rpms do
-    old_rpms = FileList.new
-    modern_rpms = FileList.new
-    sign_dists = 'el5', 'el6', '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'
-          modern_rpms += FileList[rpm_stagedir] + FileList[srpm_stagedir]
-        else
-          old_rpms += FileList[rpm_stagedir] + FileList[srpm_stagedir]
+if @build.build_pe
+  namespace :pe do
+    desc "Sign all staged in rpms in pkg"
+    task :sign_rpms do
+      old_rpms = FileList.new
+      modern_rpms = FileList.new
+      sign_dists = 'el5', 'el6', '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'
+            modern_rpms += FileList[rpm_stagedir] + FileList[srpm_stagedir]
+          else
+            old_rpms += FileList[rpm_stagedir] + FileList[srpm_stagedir]
+          end
         end
       end
+      sign_el5(old_rpms) unless old_rpms.empty?
+      sign_modern(modern_rpms) unless modern_rpms.empty?
     end
-    sign_el5(old_rpms) unless old_rpms.empty?
-    sign_modern(modern_rpms) unless modern_rpms.empty?
   end
 end
-

data/ext/packaging/tasks/pe_sles.rake

@@ -4,24 +4,24 @@
 # directories/files set up for building an rpm.
 # return the directory
 
-if @build_pe
+if @build.build_pe
   def prep_sles_dir
     temp = get_temp
-    check_file("pkg/#{@name}-#{@version}.tar.gz")
+    check_file("pkg/#{@build.project}-#{@build.version}.tar.gz")
     mkdir_pr temp, "#{temp}/SOURCES", "#{temp}/SPECS"
-    if @sign_tar
+    if @build.sign_tar
       Rake::Task["pl:sign_tar"].invoke
-      cp_p "pkg/#{@name}-#{@version}.tar.gz.asc", "#{temp}/SOURCES"
+      cp_p "pkg/#{@build.project}-#{@build.version}.tar.gz.asc", "#{temp}/SOURCES"
     end
-    cp_p "pkg/#{@name}-#{@version}.tar.gz", "#{temp}/SOURCES"
-    erb "ext/redhat/#{@name}.spec.erb", "#{temp}/SPECS/#{@name}.spec"
+    cp_p "pkg/#{@build.project}-#{@build.version}.tar.gz", "#{temp}/SOURCES"
+    erb "ext/redhat/#{@build.project}.spec.erb", "#{temp}/SPECS/#{@build.project}.spec"
     temp
   end
 
   namespace :pe do
     # Temporary task to pull down pe dependencies until this is NFS-mounted
-    task :retrieve_sles_deps => 'pl:load_extras' do
-      rsync_from("#{@sles_repo_path}/#{@pe_version}/repos/sles-*", @sles_repo_host, "#{ENV['HOME']}/package_repos/")
+    task :retrieve_sles_deps => 'pl:fetch' do
+      rsync_from("#{@build.sles_repo_path}/#{@build.pe_version}/repos/sles-*", @build.sles_repo_host, "#{ENV['HOME']}/package_repos/")
       FileList["#{ENV['HOME']}/package_repos/*"].each do |f|
         update_rpm_repo(f) if File.directory?(f)
       end
@@ -35,9 +35,8 @@ if @build_pe
       end
     end
 
-    # pl:setup_el_dirs is defined in mock.rake
     desc "Build a sles rpm from this repo"
-    task :local_sles => ['package:tar', 'pl:setup_el_dirs', 'pl:fetch', 'pl:load_extras', 'pe:retrieve_sles_deps'] do
+    task :local_sles => ['package:tar', 'pl:fetch', 'pe:retrieve_sles_deps'] do
       check_tool('build')
       check_tool('linux32')
       check_tool('linux64')
@@ -45,41 +44,46 @@ if @build_pe
       work_dir          = prep_sles_dir
       build_source_dir  = "#{work_dir}/SOURCES"
       build_spec_dir    = "#{work_dir}/SPECS"
-      build_spec        = "#{build_spec_dir}/#{@name}.spec"
+      build_spec        = "#{build_spec_dir}/#{@build.project}.spec"
       build_dest_dir    = "usr/src/packages"
       noarch            = FALSE
-      build_dep_dir     = @sles_build_deps_dir
-      build_os_dep_dir  = @sles_build_iso_dir
       built_arch        = ''
-      @sles_arch_repos.each do |arch, deps_repo|
+      @build.sles_arch_repos.each do |arch, deps_repo|
         if noarch == FALSE
-          linux_cmd = arch == 'i586' ? 'linux32' : 'linux64'
-          sh "yes | sudo #{linux_cmd} build \
-            --rpms        #{deps_repo}:#{ENV['HOME']}/package_repos/sles-11-#{arch} \
-            --root        #{build_root}/#{arch}                                     \
-            --rsync-src   #{build_source_dir}                                       \
-            --rsync-dest  /usr/src/packages/SOURCES                                 \
-            --no-checks   #{build_spec}                                             \
-            --arch        #{arch} || true"
-          rpms = FileList["#{build_root}/#{arch}/#{build_dest_dir}/RPMS/**/*.rpm"]
-          srpms = FileList["#{build_root}/#{arch}/#{build_dest_dir}/SRPMS/**/*.rpm"]
-          if rpms.empty?
-            STDERR.puts "No RPMS were built. Perhaps an error occurred?"
-            exit 1
+          bench = Benchmark.realtime do
+            linux_cmd = arch == 'i586' ? 'linux32' : 'linux64'
+            sh "yes | sudo #{linux_cmd} build \
+              --rpms        #{deps_repo}:#{ENV['HOME']}/package_repos/sles-11-#{arch} \
+              --root        #{build_root}/#{arch}                                     \
+              --rsync-src   #{build_source_dir}                                       \
+              --rsync-dest  /usr/src/packages/SOURCES                                 \
+              --no-checks   #{build_spec}                                             \
+              --arch        #{arch} || true"
+            rpms = FileList["#{build_root}/#{arch}/#{build_dest_dir}/RPMS/**/*.rpm"]
+            srpms = FileList["#{build_root}/#{arch}/#{build_dest_dir}/SRPMS/**/*.rpm"]
+            if rpms.empty?
+              STDERR.puts "No RPMS were built. Perhaps an error occurred?"
+              exit 1
+            end
+            built_arch = arch
+            %x{mkdir -p pkg/pe/rpm/sles-11-{srpms,#{arch}}}
+            cp(rpms, "pkg/pe/rpm/sles-11-#{arch}")
+            cp(srpms, "pkg/pe/rpm/sles-11-srpms")
+            noarch = rpms.exclude(/noarch/).empty?
+            rm_rf build_root
+            rm_rf work_dir
           end
-          built_arch = arch
-          cp rpms, "pkg/pe/rpm/sles-11-#{arch}"
-          cp srpms, "pkg/pe/rpm/sles-11-srpms"
-          noarch = rpms.exclude(/noarch/).empty?
-          rm_rf build_root
-          rm_rf work_dir
+          # See 30_metrics.rake to see what this is doing
+          add_metrics({ :dist => 'sles', :bench => bench }) if @build.benchmark
         else
-          arches_to_copy_to = @sles_arch_repos.keys - [ built_arch ]
+          arches_to_copy_to = @build.sles_arch_repos.keys - [ built_arch ]
           arches_to_copy_to.each do |other_arch|
-            cp FileList["pkg/pe/rpm/sles-11-#{built_arch}/*"], "pkg/pe/rpm/sles-11-#{other_arch}"
+            %x{mkdir -p pkg/pe/rpm/sles-11-#{other_arch}}
+            cp(FileList["pkg/pe/rpm/sles-11-#{built_arch}/*"], "pkg/pe/rpm/sles-11-#{other_arch}")
           end
         end
       end
+      post_metrics if @build.benchmark
       cd 'pkg/pe/rpm' do
         if File.exist?('sles-11-i586')
           mkdir_p 'sles-11-i386'
@@ -87,7 +91,7 @@ if @build_pe
           rm_rf 'sles-11-i586'
         end
       end
-      if @team == 'release'
+      if @build.team == 'release'
         Rake::Task["pe:sign_rpms"].invoke
       end
     end

data/ext/packaging/tasks/pe_tar.rake

@@ -0,0 +1,5 @@
+##
+# An alias from pe:tar to package:tar, for easier automation in jenkins.rake
+namespace :pe do
+  task :local_tar => ["package:tar"]
+end

data/ext/packaging/tasks/release.rake

@@ -7,10 +7,10 @@ namespace :pl do
     if confirm_ship(FileList["pkg/*.gem"])
       invoke_task("pl:ship_gem")
     end
-  end if @build_gem
+  end if @build.build_gem
 
-  desc "Release deb RCs, e.g. package:tar, pl:{deb_all_rc, sign_deb_changes, ship_debs}"
   task :release_deb_rc do
+    deprecate("pl:release_deb_rc", "pl:release_deb")
     load_keychain if has_tool('keychain')
     invoke_task("pl:deb_all_rc")
     invoke_task("pl:sign_deb_changes")
@@ -19,8 +19,18 @@ namespace :pl do
     end
   end
 
-  desc "Release deb FINALs, e.g. package:tar, pl:{deb_all, sign_deb_changes, ship_debs}"
   task :release_deb_final do
+    deprecate("pl:release_deb_final", "pl:release_deb")
+    load_keychain if has_tool('keychain')
+    invoke_task("pl:deb_all")
+    invoke_task("pl:sign_deb_changes")
+    if confirm_ship(FileList["pkg/deb/**/*"])
+      invoke_task("pl:ship_debs")
+    end
+  end
+
+  desc "Release deb, e.g. package:tar, pl:{deb_all, sign_deb_changes, ship_debs}"
+  task :release_deb do
     load_keychain if has_tool('keychain')
     invoke_task("pl:deb_all")
     invoke_task("pl:sign_deb_changes")
@@ -29,29 +39,39 @@ namespace :pl do
     end
   end
 
-  desc "Release rpm RCs, e.g. package:tar, pl:{mock_rc, sign_rpms, ship_rpms, update_yum_repo}"
   task :release_rpm_rc do
+    deprecate("pl:release_rpm_rc", "pl:release_rpm")
     invoke_task("pl:mock_rc")
     invoke_task("pl:sign_rpms")
     if confirm_ship(FileList["pkg/el/**/*", "pkg/fedora/**/*"])
       invoke_task("pl:ship_rpms")
-      invoke_task("pl:remote_update_yum_repo")
+      invoke_task("pl:remote:update_yum_repo")
     end
   end
 
-  desc "Release rpm FINALs, e.g. package:tar, pl:{mock_final, sign_rpms, ship_rpms, update_yum_repo}"
   task :release_rpm_final do
+    deprecate("pl:release_rpm_final", "pl:release_rpm")
     invoke_task("pl:mock_final")
     invoke_task("pl:sign_rpms")
     if confirm_ship(FileList["pkg/el/**/*", "pkg/fedora/**/*"])
       invoke_task("pl:ship_rpms")
-      invoke_task("pl:remote_update_yum_repo")
+      invoke_task("pl:remote:update_yum_repo")
+    end
+  end
+
+  desc "Release rpms, e.g. package:tar, pl:{mock_all, sign_rpms, ship_rpms, update_yum_repo}"
+  task :release_rpm do
+    invoke_task("pl:mock_all")
+    invoke_task("pl:sign_rpms")
+    if confirm_ship(FileList["pkg/el/**/*", "pkg/fedora/**/*"])
+      invoke_task("pl:ship_rpms")
+      invoke_task("pl:remote:update_yum_repo")
     end
   end
 
-  if File.exist?("#{ENV['HOME']}/.packaging/#{@builder_data_file}")
+  if File.exist?("#{ENV['HOME']}/.packaging")
     desc "Release tarball, e.g. package:tar, pl:{sign_tar, ship_tar}"
-    task :release_tar => ['pl:fetch', 'pl:load_extras'] do
+    task :release_tar => 'pl:fetch' do
       invoke_task("package:tar")
       invoke_task("pl:sign_tar")
       if confirm_ship(FileList["pkg/*tar.gz*"])
@@ -60,15 +80,15 @@ namespace :pl do
     end
 
     desc "Release dmg, e.g. package:apple, pl:ship_dmg"
-    task :release_dmg => ['pl:fetch', 'pl:load_extras'] do
+    task :release_dmg => 'pl:fetch' do
       sh "rvmsudo rake package:apple"
       if confirm_ship(FileList["pkg/apple/*.dmg"])
         Rake::Task["pl:ship_dmg"].execute
       end
-    end if @build_dmg
+    end if @build.build_dmg
 
     desc "Release ips, e.g. pl:ips, pl:ship_ips"
-    task :release_ips => ['pl:fetch', 'pl:load_extras'] do
+    task :release_ips => 'pl:fetch' do
       Rake::Task['pl:ips'].invoke
       Rake::Task['pl:ship_ips'].invoke
     end

data/ext/packaging/tasks/remote_build.rake

@@ -1,112 +1,170 @@
 # Tasks for remote building on builder hosts
 
-if File.exist?("#{ENV['HOME']}/.packaging/#{@builder_data_file}")
+if File.exist?("#{ENV['HOME']}/.packaging")
   namespace 'pl' do
-    task :remote_build, :host, :treeish, :task, :tar do |t, args|
-      host                    = args.host
-      treeish                 = args.treeish
-      task                    = args.task
-      tar                     = args.tar
-      remote_repo             = remote_bootstrap(host, treeish, tar)
-      STDOUT.puts "Beginning package build on #{host}"
-      remote_ssh_cmd(host, "cd #{remote_repo} ; rake #{task} ANSWER_OVERRIDE=no")
-      rsync_from("#{remote_repo}/pkg/", host, 'pkg/')
-      remote_ssh_cmd(host, "rm -rf #{remote_repo}")
-      STDOUT.puts "packages from #{host} staged in pkg/ directory"
-    end
+    namespace :remote do
+      task :build, :host, :treeish, :task, :tar do |t, args|
+        if source_dirty?
+          warn "The source tree is dirty, e.g. there are uncommited changes. Please commit/discard changes and try again."
+          exit 1
+        end
+        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)
+        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/')
+        remote_ssh_cmd(host, "rm -rf #{remote_repo}")
+        remote_ssh_cmd(host, "rm #{build_params}")
+        STDOUT.puts "packages from #{host} staged in pkg/ directory"
+      end
 
-    desc "Execute release_deb_rc full build set on remote debian build host"
-    task :remote_deb_rc => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@deb_build_host, 'HEAD', "pl:release_deb_rc COW='#{@cows}'")
-    end
+      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")
+      end
 
-    desc "Execute deb_all_rc build on remote debian build host (no signing)"
-    task :remote_deb_rc_build => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@deb_build_host, 'HEAD', "pl:deb_all_rc COW='#{@cows}'")
-    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")
+      end
 
-    desc "Execute release_deb_final full build set on remote debian build host"
-    task :remote_deb_final => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@deb_build_host, 'HEAD', "pl:release_deb_final COW='#{@cows}'")
-    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")
+      end
 
-    desc "Execute deb_all on remote debian build host (no signing)"
-    task :remote_deb_final_build => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@deb_build_host, 'HEAD', "pl:deb_all COW='#{@cows}'")
-    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")
+      end
 
-    desc "Execute release_rpm_rc full build set on remote rpm build host"
-    task :remote_rpm_rc => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@rpm_build_host, 'HEAD', "pl:release_rpm_rc MOCK='#{@rc_mocks}'")
-    end
+      desc "Execute pl:deb (single default cow deb package) on remote debian build host (no signing)"
+      task :deb => 'pl:fetch' do
+        Rake::Task["pl:remote:build"].reenable
+        Rake::Task["pl:remote:build"].invoke(@build.deb_build_host, 'HEAD', "pl:deb")
+      end
 
-    desc "Execute mock_rc on remote rpm build host (no signing)"
-    task :remote_rpm_rc_build => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@rpm_build_host, 'HEAD', "pl:mock_rc MOCK='#{@rc_mocks}'")
-    end
+      desc "Execute pl:deb_all on remote debian build host (no signing)"
+      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")
+      end
 
-    desc "Execute release_rpm_final full build set on remote rpm build host"
-    task :remote_rpm_final => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@rpm_build_host, 'HEAD', "pl:release_rpm_final MOCK='#{@final_mocks}'")
-    end
+      desc "Execute remote pl:release_deb_all full build set on remote debian build host"
+      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")
+      end
 
-    desc "Execute mock_final on remote rpm build host (no signing)"
-    task :remote_mock_final => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@rpm_build_host, 'HEAD', "pl:mock_final MOCK='#{@final_mocks}'")
-    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")
+      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")
+      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")
+      end
+
+      desc "Execute remote pl:release_rpm full build set on remote rpm build host"
+      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")
+      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")
+      end
+
+      desc "Execute pl:mock (single default mock package) on remote rpm build host (no signing)"
+      task :mock => 'pl:fetch' do
+        Rake::Task["pl:remote:build"].reenable
+        Rake::Task["pl:remote:build"].invoke(@build.rpm_build_host, 'HEAD', "pl:mock")
+      end
+
+      desc "Execute pl:mock_all on remote rpm build host (no signing)"
+      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")
+      end
+
+      desc "Execute pl:ips on remote ips build host"
+      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
+
+      desc "Execute package:apple on remote apple build host"
+      task :dmg => 'pl:fetch' do
+        # Because we use rvmsudo for apple, we end up replicating the :remote_build task
+        host                    = @build.osx_build_host
+        treeish                 = 'HEAD'
+        task                    = "package:apple"
+        remote_repo             = remote_bootstrap(host, treeish)
+        build_params            = remote_buildparams(host, @build)
+        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 # remote namespace
 
-    desc "Execute pl:ips on remote ips build host"
-    task :remote_ips => ['pl:fetch', 'pl:load_extras'] do
-      Rake::Task["pl:remote_build"].reenable
-      Rake::Task["pl:remote_build"].invoke(@ips_build_host, 'HEAD', 'pl:ips', 'gtar')
-    end if @build_ips
-
-    desc "Execute package:apple on remote apple build host"
-    task :remote_dmg => ['pl:fetch', 'pl:load_extras'] do
-      # Because we use rvmsudo for apple, we end up replicating the :remote_build task
-      host                    = @osx_build_host
-      treeish                 = 'HEAD'
-      task                    = "package:apple"
-      remote_repo             = remote_bootstrap(host, treeish)
-      puts "Beginning package build on #{host}"
-      remote_ssh_cmd(host, "cd #{remote_repo} ; rvmsudo rake #{task}")
-      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_dmg
-
-    desc "UBER RC build: build and ship RC tar, gem (as applicable), remote dmg, remote deb, remote rpm"
     task :uber_rc do
-      Rake::Task["package:gem"].invoke if @build_gem
+      deprecate("pl:uber_rc", "pl:uber_release")
+      Rake::Task["package:gem"].invoke if @build.build_gem
       Rake::Task["pl:remote_deb_rc"].invoke
       Rake::Task["pl:remote_rpm_rc"].execute
-      Rake::Task["pl:remote_dmg"].execute if @build_dmg
+      Rake::Task["pl:remote:dmg"].execute if @build.build_dmg
       Rake::Task["package:tar"].execute
       Rake::Task["pl:sign_tar"].invoke
       Rake::Task["pl:uber_ship"].execute
-      Rake::Task["pl:remote_freight_devel"].invoke
-      Rake::Task["pl:remote_update_yum_repo"].invoke
+      Rake::Task["pl:remote:freight"].invoke
+      Rake::Task["pl:remote:update_yum_repo"].invoke
     end
 
-    desc "UBER FINAL build: build and ship FINAL tar, gem (as applicable), remote dmg, remote deb, remote rpm"
     task :uber_final do
-      Rake::Task["package:gem"].invoke if @build_gem
+      deprecate("pl:uber_final", "pl:uber_release")
+      Rake::Task["package:gem"].invoke if @build.build_gem
       Rake::Task["pl:remote_deb_final"].invoke
       Rake::Task["pl:remote_rpm_final"].execute
-      Rake::Task["pl:remote_dmg"].execute if @build_dmg
+      Rake::Task["pl:remote:dmg"].execute if @build.build_dmg
+      Rake::Task["package:tar"].execute
+      Rake::Task["pl:sign_tar"].invoke
+      Rake::Task["pl:uber_ship"].execute
+      Rake::Task["pl:remote:freight"].invoke
+      Rake::Task["pl:remote:update_yum_repo"].invoke
+    end
+
+    desc "UBER build: build, sign and ship tar, gem (as applicable), remote dmg, remote deb, remote rpm"
+    task :uber_release do
+      Rake::Task["package:gem"].invoke if @build.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["package:tar"].execute
       Rake::Task["pl:sign_tar"].invoke
       Rake::Task["pl:uber_ship"].execute
-      Rake::Task["pl:remote_freight_final"].invoke
-      Rake::Task["pl:remote_update_yum_repo"].invoke
+      Rake::Task["pl:remote:freight"].invoke
+      Rake::Task["pl:remote:update_yum_repo"].invoke
     end
   end
 end