packaging 0.99.2 → 0.99.3

data/spec/lib/packaging/platforms_spec.rb

@@ -162,4 +162,16 @@ describe 'Pkg::Platforms' do
       end
     end
   end
+
+  describe '#generic_platform_tag' do
+    it 'fails for unsupported platforms' do
+      expect { Pkg::Platforms.generic_platform_tag('butts') }.to raise_error
+    end
+
+    it 'returns a supported platform tag containing the supplied platform' do
+      Pkg::Platforms.supported_platforms.each do |platform|
+        expect(Pkg::Platforms.platform_tags).to include(Pkg::Platforms.generic_platform_tag(platform))
+      end
+    end
+  end
 end

data/spec/lib/packaging/repo_spec.rb

@@ -94,4 +94,40 @@ describe "#Pkg::Repo" do
       Pkg::Repo.create_all_repo_archives("project", "version")
     end
   end
+
+  describe "#argument_required?" do
+    let(:repo_command) { "some command with __REPO_PATH__ but not repo name or anything" }
+    let(:required_arg) { 'repo_path' }
+    let(:optional_arg) { 'repo_name' }
+
+    it 'should return true if command requires arg' do
+      expect(Pkg::Repo.argument_required?(required_arg, repo_command)).to be_true
+    end
+
+    it 'should return false if command does not need arg' do
+      expect(Pkg::Repo.argument_required?(optional_arg, repo_command)).to be_false
+    end
+  end
+
+  describe "#update_repo" do
+    let(:remote_host) { 'weth.delivery.puppetlabs.net' }
+    let(:repo_command) { "some command with __REPO_NAME__ and __REPO_PATH__ and stuff" }
+    let(:repo_name) { 'puppet5' }
+    let(:repo_path) { '/opt/repository/apt' }
+    let(:apt_releases) { ['stretch', 'trusty', 'xenial'] }
+
+    before(:each) do
+      allow(Pkg::Util::Gpg).to receive(:key)
+      allow(Pkg::Config).to receive(:apt_releases).and_return(apt_releases)
+    end
+
+    it 'should fail if required params are nil' do
+      expect{ Pkg::Repo.update_repo(remote_host, repo_command, { :repo_path => repo_path }) }.to raise_error(RuntimeError, /Missing required argument 'repo_name'/)
+    end
+
+    it 'should execute command if optional params are nil' do
+      expect(Pkg::Util::Net).to receive(:remote_ssh_cmd).with(remote_host, "some command with #{repo_name} and #{repo_path} and stuff")
+      Pkg::Repo.update_repo(remote_host, repo_command, { :repo_name => repo_name, :repo_path => repo_path })
+    end
+  end
 end

data/spec/lib/packaging/retrieve_spec.rb

@@ -17,8 +17,8 @@ describe 'Pkg::Retrieve' do
     'ubuntu-16.04-amd64' => {:artifact => './deb/xenial/PC1/puppet-agent_5.3.2.155.gb25e649-1xenial_amd64.deb'},
     'windows-2012-x64' => {:artifact => './windows/puppet-agent-x64.msi'},
   }}
-  build_url = "builds.delivery.puppetlabs.net/#{project}/#{ref}"
-  build_path = "/opt/jenkins-builds/#{project}/#{ref}"
+  build_url = "builds.delivery.puppetlabs.net/#{project}/#{ref}/#{remote_target}"
+  build_path = "/opt/jenkins-builds/#{project}/#{ref}/#{remote_target}"
 
   before :each do
     allow(Pkg::Config).to receive(:project).and_return(project)
@@ -86,13 +86,13 @@ describe 'Pkg::Retrieve' do
   describe '#retrieve_all' do
     it 'should try to use wget first' do
       expect(Pkg::Retrieve).to receive(:default_wget)
-      Pkg::Retrieve.retrieve_all(build_url, build_path, remote_target, local_target)
+      Pkg::Retrieve.retrieve_all(build_url, build_path, local_target)
     end
 
     it 'should use rsync if wget is not found' do
       allow(Pkg::Util::Tool).to receive(:find_tool).with('wget').and_return(nil)
       expect(Pkg::Util::Net).to receive(:rsync_from)
-      Pkg::Retrieve.retrieve_all(build_url, build_path, remote_target, local_target)
+      Pkg::Retrieve.retrieve_all(build_url, build_path, local_target)
     end
   end
 end

data/tasks/apple.rake

@@ -86,6 +86,7 @@ end
 def build_dmg
   # Local Variables
   dmg_format_code   = 'UDZO'
+  dmg_filesystem    = 'HFS+'
   zlib_level        = '9'
   dmg_format_option = "-imagekey zlib-level=#{zlib_level}"
   dmg_format        = "#{dmg_format_code} #{dmg_format_option}"
@@ -108,6 +109,7 @@ def build_dmg
     -uid 99 \
     -gid 99 \
     -ov \
+    -fs #{dmg_filesystem} \
     -format #{dmg_format} \
     #{dmg_file}")
 

data/tasks/jenkins.rake

@@ -265,9 +265,25 @@ namespace :pl do
       end
     end
 
+    task :stage_nightlies => "pl:fetch" do
+      tasks = %w(
+        jenkins:retrieve
+        jenkins:sign_all
+        ship_nightly_rpms
+        ship_nightly_debs
+        ship_nightly_dmg
+        ship_nightly_swix
+        ship_nightly_msi
+      )
+      tasks.map { |t| "pl:#{t}" }.each do |t|
+        puts "Running #{t} . . ."
+        Rake::Task[t].invoke
+      end
+    end
+
     task :ship_nightlies => "pl:fetch" do
-      Rake::Task['pl:jenkins:uber_ship_lite'].invoke
-      Rake::Task['pl:remote:update_foss_repos'].invoke
+      Rake::Task['pl:jenkins:stage_nightlies'].invoke
+      Rake::Task['pl:remote:update_nightly_repos'].invoke
       Rake::Task['pl:remote:deploy_nightlies_to_s3'].invoke
     end
 

data/tasks/nightly_repos.rake

@@ -42,9 +42,9 @@ DOC
       Pkg::Rpm::Repo.create_local_repos('repos')
       Pkg::Rpm::Repo.sign_repos('repos')
       Pkg::Deb::Repo.sign_repos('repos', 'Apt repository for signed builds')
-      Pkg::OSX.sign('repos') unless Dir['repos/apple/**/*.dmg'].empty?
-      Pkg::IPS.sign('repos') unless Dir['repos/solaris/11/**/*.p5p'].empty?
-      Pkg::MSI.sign('repos') unless Dir['repos/windows/**/*.msi'].empty?
+      Pkg::Sign::Dmg.sign('repos') unless Dir['repos/apple/**/*.dmg'].empty?
+      Pkg::Sign::Ips.sign('repos') unless Dir['repos/solaris/11/**/*.p5p'].empty?
+      Pkg::Sign::Msi.sign('repos') unless Dir['repos/windows/**/*.msi'].empty?
     end
 
     task :ship_signed_repos, [:target_prefix] => "pl:fetch" do |t, args|

data/tasks/retrieve.rake

@@ -17,13 +17,14 @@ namespace :pl do
       remote_target = args.remote_target || "artifacts"
       local_target = args.local_target || "pkg"
       mkdir_p local_target
-      build_url = "http://#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}"
-      build_path = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}"
+      build_url = "http://#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{remote_target}"
+      build_path = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{remote_target}"
       if Pkg::Config.foss_only
         Pkg::Retrieve.foss_only_retrieve(build_url, local_target)
       else
-        Pkg::Retrieve.retrieve_all(build_url, build_path, remote_target, local_target)
+        Pkg::Retrieve.retrieve_all(build_url, build_path, local_target)
       end
+      fail "Uh oh, looks like we didn't find anything in #{local_target} when attempting to retrieve from #{build_url}!" if Dir["#{local_target}/*"].empty?
       puts "Packages staged in #{local_target}"
     end
   end
@@ -36,9 +37,9 @@ if Pkg::Config.build_pe
       task :retrieve, [:remote_target, :local_target] => 'pl:fetch' do |t, args|
         remote_target = args.remote_target || "artifacts"
         local_target = args.local_target || "pkg"
-        build_url = "http://#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}"
-        build_path = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}"
-        Pkg::Retrieve.retrieve_all(build_url, build_path, remote_target, local_target)
+        build_url = "http://#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{remote_target}"
+        build_path = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{remote_target}"
+        Pkg::Retrieve.retrieve_all(build_url, build_path, local_target)
       end
     end
   end

data/tasks/ship.rake

@@ -5,27 +5,39 @@ namespace :pl do
     # 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 yum repository on '#{Pkg::Config.yum_staging_server}'"
+    desc "Update '#{Pkg::Config.repo_name}' yum repository on '#{Pkg::Config.yum_staging_server}'"
     task update_yum_repo: 'pl:fetch' do
-      if Pkg::Util::Version.final?
-        path = Pkg::Config.yum_repo_path
-      else
-        path = Pkg::Config.nonfinal_yum_repo_path || Pkg::Config.yum_repo_path
+      command = Pkg::Config.yum_repo_command || 'rake -f /opt/repository/Rakefile mk_repo'
+      $stdout.puts "Really run remote repo update on '#{Pkg::Config.yum_staging_server}'? [y,n]"
+      if Pkg::Util.ask_yes_or_no
+        Pkg::Repo.update_repo(Pkg::Config.yum_staging_server, command, { :repo_name => Pkg::Config.repo_name, :repo_path => Pkg::Config.yum_repo_path, :repo_host => Pkg::Config.yum_staging_server })
       end
-      yum_whitelist = {
-        __REPO_NAME__: Pkg::Paths.repo_name,
-        __REPO_PATH__: path,
-        __REPO_HOST__: Pkg::Config.yum_staging_server,
-        __GPG_KEY__: Pkg::Util::Gpg.key
-      }
+    end
 
+    desc "Update all final yum repositories on '#{Pkg::Config.yum_staging_server}'"
+    task update_all_final_yum_repos: 'pl:fetch' do
+      command = Pkg::Config.yum_repo_command || 'rake -f /opt/repository/Rakefile mk_repo'
       $stdout.puts "Really run remote repo update on '#{Pkg::Config.yum_staging_server}'? [y,n]"
       if Pkg::Util.ask_yes_or_no
-        if Pkg::Config.yum_repo_command
-          Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.yum_staging_server, Pkg::Util::Misc.search_and_replace(Pkg::Config.yum_repo_command, yum_whitelist))
-        else
-          Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.yum_staging_server, 'rake -f /opt/repository/Rakefile mk_repo')
-        end
+        Pkg::Repo.update_repo(Pkg::Config.yum_staging_server, command, { :repo_name => '', :repo_path => Pkg::Config.yum_repo_path, :repo_host => Pkg::Config.yum_staging_server })
+      end
+    end
+
+    desc "Update '#{Pkg::Config.nonfinal_repo_name}' nightly yum repository on '#{Pkg::Config.yum_staging_server}'"
+    task update_nightlies_yum_repo: 'pl:fetch' do
+      command = Pkg::Config.yum_repo_command || 'rake -f /opt/repository-nightlies/Rakefile mk_repo'
+      $stdout.puts "Really run remote repo update on '#{Pkg::Config.yum_staging_server}'? [y,n]"
+      if Pkg::Util.ask_yes_or_no
+        Pkg::Repo.update_repo(Pkg::Config.yum_staging_server, command, { :repo_name => Pkg::Config.nonfinal_repo_name, :repo_path => Pkg::Config.nonfinal_yum_repo_path, :repo_host => Pkg::Config.yum_staging_server })
+      end
+    end
+
+    desc "Update all nightly yum repositories on '#{Pkg::Config.yum_staging_server}'"
+    task update_all_nightlies_yum_repos: 'pl:fetch' do
+      command = Pkg::Config.yum_repo_command || 'rake -f /opt/repository-nightlies/Rakefile mk_repo'
+      $stdout.puts "Really run remote repo update on '#{Pkg::Config.yum_staging_server}'? [y,n]"
+      if Pkg::Util.ask_yes_or_no
+        Pkg::Repo.update_repo(Pkg::Config.yum_staging_server, command, { :repo_name => '', :repo_path => Pkg::Config.nonfinal_yum_repo_path, :repo_host => Pkg::Config.yum_staging_server })
       end
     end
 
@@ -33,35 +45,17 @@ namespace :pl do
 
     desc "Update remote apt repository on '#{Pkg::Config.apt_signing_server}'"
     task update_apt_repo: 'pl:fetch' do
-      if Pkg::Util::Version.final?
-        path = Pkg::Config.apt_repo_path
-        cmd = Pkg::Config.apt_repo_command
-      else
-        path = Pkg::Config.nonfinal_apt_repo_path || Pkg::Config.apt_repo_path
-        cmd = Pkg::Config.nonfinal_apt_repo_command || Pkg::Config.apt_repo_command
-      end
-      apt_whitelist = {
-        __REPO_NAME__: Pkg::Paths.repo_name,
-        __REPO_PATH__: path,
-        __REPO_URL__: Pkg::Config.apt_repo_url,
-        __REPO_HOST__: Pkg::Config.apt_host,
-        __APT_PLATFORMS__: Pkg::Config.apt_releases.join(' '),
-        __GPG_KEY__: Pkg::Util::Gpg.key
-      }
+      $stdout.puts "Really run remote repo update on '#{Pkg::Config.apt_signing_server}'? [y,n]"
+      if Pkg::Util.ask_yes_or_no
+        Pkg::Repo.update_repo(Pkg::Config.apt_signing_server, Pkg::Config.apt_repo_command, { :repo_name => Pkg::Config.repo_name, :repo_path => Pkg::Config.apt_repo_path, :repo_host => Pkg::Config.apt_host, :repo_url => Pkg::Config.apt_repo_url })
+      end
+    end
 
+    desc "Update nightlies apt repository on '#{Pkg::Config.apt_signing_server}'"
+    task update_nightlies_apt_repo: 'pl:fetch' do
       $stdout.puts "Really run remote repo update on '#{Pkg::Config.apt_signing_server}'? [y,n]"
       if Pkg::Util.ask_yes_or_no
-        if cmd
-          Pkg::Util::Net.remote_ssh_cmd(
-            Pkg::Config.apt_signing_server,
-            Pkg::Util::Misc.search_and_replace(
-              cmd,
-              apt_whitelist
-            )
-          )
-        else
-          warn %(Pkg::Config#apt_repo_command returned something unexpected, so no attempt will be made to update remote repos)
-        end
+        Pkg::Repo.update_repo(Pkg::Config.apt_signing_server, Pkg::Config.nonfinal_apt_repo_command, { :repo_name => Pkg::Config.nonfinal_repo_name, :repo_path => Pkg::Config.nonfinal_apt_repo_path, :repo_host => Pkg::Config.apt_host, :repo_url => Pkg::Config.apt_repo_url })
       end
     end
 
@@ -71,6 +65,12 @@ namespace :pl do
       Rake::Task['pl:remote:update_yum_repo'].invoke
     end
 
+    desc "Update nightlies apt and yum repos"
+    task :update_nightly_repos => "pl:fetch" do
+      Rake::Task['pl:remote:update_nightlies_apt_repo'].invoke
+      Rake::Task['pl:remote:update_nightlies_yum_repo'].invoke
+    end
+
     desc "Update remote ips repository on #{Pkg::Config.ips_host}"
     task :update_ips_repo  => 'pl:fetch' do
       if Dir['pkg/ips/pkgs/**/*'].empty? && Dir['pkg/solaris/11/**/*'].empty?
@@ -251,41 +251,22 @@ namespace :pl do
 
   desc "Ship mocked rpms to #{Pkg::Config.yum_staging_server}"
   task ship_rpms: 'pl:fetch' do
-    if Pkg::Util::Version.final?
-      path = Pkg::Config.yum_repo_path
-    else
-      path = Pkg::Config.nonfinal_yum_repo_path || Pkg::Config.yum_repo_path
-    end
-    Pkg::Util::Ship.ship_pkgs(['pkg/**/*.rpm', 'pkg/**/*.srpm'], Pkg::Config.yum_staging_server, path)
+    Pkg::Util::Ship.ship_rpms('pkg', Pkg::Config.yum_repo_path)
+  end
 
-    # I really don't care which one we grab, it just has to be some supported
-    # version and architecture from the `el` hash. So here we're just grabbing
-    # the first one, parsing out some info, and breaking out of the loop. Not
-    # elegant, I know, but effective.
-    Pkg::Platforms::PLATFORM_INFO['el'].each do |key, value|
-      generic_platform_tag = "el-#{key}-#{value[:architectures][0]}"
-      Pkg::Util::Ship.create_rolling_repo_link(generic_platform_tag, Pkg::Config.yum_staging_server, path)
-      break
-    end
+  desc "Ship nightly rpms to #{Pkg::Config.yum_staging_server}"
+  task ship_nightly_rpms: 'pl:fetch' do
+    Pkg::Util::Ship.ship_rpms('pkg', Pkg::Config.nonfinal_yum_repo_path)
   end
 
   desc "Ship cow-built debs to #{Pkg::Config.apt_signing_server}"
   task ship_debs: 'pl:fetch' do
-    if Pkg::Util::Version.final?
-      staging_path = Pkg::Config.apt_repo_staging_path
-    else
-      staging_path = Pkg::Config.nonfinal_apt_repo_staging_path || Pkg::Config.apt_repo_staging_path
-    end
-    Pkg::Util::Ship.ship_pkgs(['pkg/**/*.debian.tar.gz', 'pkg/**/*.orig.tar.gz', 'pkg/**/*.dsc', 'pkg/**/*.deb', 'pkg/**/*.changes'], Pkg::Config.apt_signing_server, staging_path, chattr: false)
+    Pkg::Util::Ship.ship_debs('pkg', Pkg::Config.apt_repo_staging_path, chattr: false)
+  end
 
-    # We need to iterate through all the supported platforms here because of
-    # how deb repos are set up. Each codename will have its own link from the
-    # current versioned repo (i.e., puppet5) to the rolling repo. The one thing
-    # we don't care about is architecture, so we just grab the first supported
-    # architecture for the codename we're working with at the moment.
-    Pkg::Platforms.codenames.each do |codename|
-      Pkg::Util::Ship.create_rolling_repo_link(Pkg::Platforms.codename_to_tags(codename)[0], Pkg::Config.apt_signing_server, staging_path)
-    end
+  desc "Ship nightly debs to #{Pkg::Config.apt_signing_server}"
+  task ship_nightly_debs: 'pl:fetch' do
+    Pkg::Util::Ship.ship_debs('pkg', Pkg::Config.nonfinal_apt_repo_staging_path, chattr: false)
   end
 
   desc 'Ship built gem to rubygems.org, internal Gem mirror, and public file server'
@@ -353,7 +334,7 @@ namespace :pl do
     end
 
     Pkg::Util::Execution.retry_on_fail(times: 3) do
-      Pkg::Util::Ship.ship_pkgs(['pkg/*.gem*'], Pkg::Config.gem_host, Pkg::Config.gem_path, platform_independent: true)
+      Pkg::Util::Ship.ship_gem('pkg', Pkg::Config.gem_path, platform_independent: true)
     end
   end
 
@@ -361,12 +342,7 @@ namespace :pl do
   task :ship_svr4 do
     Pkg::Util::Execution.retry_on_fail(:times => 3) do
       if File.directory?("pkg/solaris/10")
-        if Pkg::Util::Version.final?
-          path = Pkg::Config.svr4_path
-        else
-          path = Pkg::Config.nonfinal_svr4_path || Pkg::Config.svr4_path
-        end
-        Pkg::Util::Ship.ship_pkgs(['pkg/**/*.pkg.gz'], Pkg::Config.svr4_host, path)
+        Pkg::Util::Ship.ship_svr4('pkg', Pkg::Config.svr4_path)
       end
     end
   end
@@ -375,12 +351,7 @@ namespace :pl do
   task :ship_p5p do
     Pkg::Util::Execution.retry_on_fail(:times => 3) do
       if File.directory?("pkg/solaris/11")
-        if Pkg::Util::Version.final?
-          path = Pkg::Config.p5p_path
-        else
-          path = Pkg::Config.nonfinal_p5p_path || Pkg::Config.p5p_path
-        end
-        Pkg::Util::Ship.ship_pkgs(['pkg/**/*.p5p'], Pkg::Config.p5p_host, path)
+        Pkg::Util::Ship.ship_p5p('pkg', Pkg::Config.p5p_path)
       end
     end
   end
@@ -399,28 +370,12 @@ namespace :pl do
     else
       path = Pkg::Config.dmg_path
     end
-    path = Pkg::Config.nonfinal_dmg_path if Pkg::Config.nonfinal_dmg_path && !Pkg::Util::Version.final?
-
-    Pkg::Util::Ship.ship_pkgs(['pkg/**/*.dmg'], Pkg::Config.dmg_staging_server, path)
-
-    # I really don't care which one we grab, it just has to be some supported
-    # version and architecture from the `osx` hash. So here we're just grabbing
-    # the first one, parsing out some info, and breaking out of the loop. Not
-    # elegant, I know, but effective.
-    Pkg::Platforms::PLATFORM_INFO['osx'].each do |key, value|
-      generic_platform_tag = "osx-#{key}-#{value[:architectures][0]}"
-      Pkg::Util::Ship.create_rolling_repo_link(generic_platform_tag, Pkg::Config.dmg_staging_server, path)
-      break
-    end
-
-    Pkg::Platforms.platform_tags_for_package_format('dmg').each do |platform_tag|
-      # TODO remove the PC1 links when we no longer need to maintain them
-      _, version, arch = Pkg::Platforms.parse_platform_tag(platform_tag)
-      Pkg::Util::Net.remote_create_latest_symlink('puppet-agent', "/opt/downloads/mac/#{version}/PC1/#{arch}", 'dmg')
+    Pkg::Util::Ship.ship_dmg('pkg', path)
+  end
 
-      # Create the latest symlink for the current supported repo
-      Pkg::Util::Net.remote_create_latest_symlink('puppet-agent', Pkg::Paths.artifacts_path(platform_tag, path), 'dmg')
-    end
+  desc "ship nightly apple dmgs to #{Pkg::Config.dmg_staging_server}"
+  task ship_nightly_dmg: 'pl:fetch' do
+    Pkg::Util::Ship.ship_dmg('pkg', Pkg::Config.nonfinal_dmg_path)
   end
 
   desc "ship Arista EOS swix packages and signatures to #{Pkg::Config.swix_staging_server}"
@@ -437,25 +392,18 @@ namespace :pl do
     else
       path = Pkg::Config.swix_path
     end
-    path = Pkg::Config.nonfinal_swix_path if Pkg::Config.nonfinal_swix_path && !Pkg::Util::Version.final?
-
-    Pkg::Util::Ship.ship_pkgs(['pkg/**/*.swix*'], Pkg::Config.swix_staging_server, path)
+    Pkg::Util::Ship.ship_swix('pkg', path)
+  end
 
-    # I really don't care which one we grab, it just has to be some supported
-    # version and architecture from the `eos` hash. So here we're just grabbing
-    # the first one, parsing out some info, and breaking out of the loop. Not
-    # elegant, I know, but effective.
-    Pkg::Platforms::PLATFORM_INFO['eos'].each do |key, value|
-      generic_platform_tag = "eos-#{key}-#{value[:architectures][0]}"
-      Pkg::Util::Ship.create_rolling_repo_link(generic_platform_tag, Pkg::Config.swix_staging_server, path)
-      break
-    end
+  desc "ship nightly Arista EOS swix packages and signatures to #{Pkg::Config.swix_staging_server}"
+  task ship_nightly_swix: 'pl:fetch' do
+    Pkg::Util::Ship.ship_swix('pkg', Pkg::Config.nonfinal_swix_path)
   end
 
   desc "ship tarball and signature to #{Pkg::Config.tar_staging_server}"
   task ship_tar: 'pl:fetch' do
     if Pkg::Config.build_tar
-      Pkg::Util::Ship.ship_pkgs(['pkg/*.tar.gz*'], Pkg::Config.tar_staging_server, Pkg::Config.tarball_path, excludes: ['signing_bundle', 'packaging-bundle'], platform_independent: true)
+      Pkg::Util::Ship.ship_tar('pkg', Pkg::Config.tarball_path, excludes: ['signing_bundle', 'packaging-bundle'], platform_independent: true)
     end
   end
 
@@ -483,29 +431,12 @@ namespace :pl do
     else
       path = Pkg::Config.msi_path
     end
-    path = Pkg::Config.nonfinal_msi_path if Pkg::Config.nonfinal_msi_path && !Pkg::Util::Version.final?
-
-    Pkg::Util::Ship.ship_pkgs(['pkg/**/*.msi'], Pkg::Config.msi_staging_server, path, excludes: ["#{Pkg::Config.project}-x(86|64).msi"])
-
-    # I really don't care which one we grab, it just has to be some supported
-    # version and architecture from the `windows` hash. So here we're just grabbing
-    # the first one, parsing out some info, and breaking out of the loop. Not
-    # elegant, I know, but effective.
-    Pkg::Platforms::PLATFORM_INFO['windows'].each do |key, value|
-      generic_platform_tag = "windows-#{key}-#{value[:architectures][0]}"
-      Pkg::Util::Ship.create_rolling_repo_link(generic_platform_tag, Pkg::Config.msi_staging_server, path)
-
-      # Create the symlinks for the latest supported repo
-      Pkg::Util::Net.remote_create_latest_symlink('puppet-agent', Pkg::Paths.artifacts_path(generic_platform_tag, path), 'msi', arch: 'x64')
-      Pkg::Util::Net.remote_create_latest_symlink('puppet-agent', Pkg::Paths.artifacts_path(generic_platform_tag, path), 'msi', arch: 'x86')
-      break
-    end
+    Pkg::Util::Ship.ship_msi('pkg', path, excludes: ["#{Pkg::Config.project}-x(86|64).msi"])
+  end
 
-    # We provide symlinks to the latest package in a given directory. This
-    # allows users to upgrade more easily to the latest version that we release
-    # TODO remove the links to PC1 when we no longer ship to that repo
-    Pkg::Util::Net.remote_create_latest_symlink('puppet-agent', '/opt/downloads/windows', 'msi', arch: 'x64')
-    Pkg::Util::Net.remote_create_latest_symlink('puppet-agent', '/opt/downloads/windows', 'msi', arch: 'x86')
+  desc "Ship nightly MSI packages to #{Pkg::Config.msi_staging_server}"
+  task ship_nightly_msi: 'pl:fetch' do
+    Pkg::Util::Ship.ship_msi('pkg', Pkg::Config.nonfinal_msi_path, excludes: ["#{Pkg::Config.project}-x(86|64).msi"])
   end
 
   desc 'UBER ship: ship all the things in pkg'