packaging 0.101.0 → 0.105.0

data/lib/packaging/util/ship.rb

@@ -1,14 +1,20 @@
 # Module for shipping all packages to places
+
+require 'English'
 require 'tmpdir'
+
 module Pkg::Util::Ship
   module_function
 
-  def collect_packages(pkg_exts, excludes = []) # rubocop:disable Metrics/MethodLength
+  def collect_packages(pkg_exts, excludes = [])
     pkgs = pkg_exts.map { |ext| Dir.glob(ext) }.flatten
     return [] if pkgs.empty?
-    excludes.each do |exclude|
-      pkgs.delete_if { |p| p.match(exclude) }
-    end if excludes
+
+    if excludes
+      excludes.each do |exclude|
+        pkgs.delete_if { |p| p.match(exclude) }
+      end
+    end
     if pkgs.empty?
       $stdout.puts "No packages with (#{pkg_exts.join(', ')}) extensions found staged in 'pkg'"
       $stdout.puts "Maybe your excludes argument (#{excludes}) is too restrictive?"
@@ -59,13 +65,13 @@ module Pkg::Util::Ship
   #   false (most paths will be platform dependent), but set to true for gems
   #   and tarballs since those just land directly under /opt/downloads/<project>
   #
-  # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
   def ship_pkgs(pkg_exts, staging_server, remote_path, opts = {})
     options = {
       excludes: [],
       chattr: true,
       platform_independent: false,
-      nonfinal: false }.merge(opts)
+      nonfinal: false
+    }.merge(opts)
 
     # First find the packages to be shipped. We must find them before moving
     # to our temporary staging directory
@@ -73,35 +79,39 @@ module Pkg::Util::Ship
     return false if local_packages.empty?
 
     tmpdir = Dir.mktmpdir
-    staged_pkgs = reorganize_packages(local_packages, tmpdir, options[:platform_independent], options[:nonfinal])
+    staged_pkgs = reorganize_packages(
+      local_packages, tmpdir, options[:platform_independent], options[:nonfinal]
+    )
 
     puts staged_pkgs.sort
     puts "Do you want to ship the above files to (#{staging_server})?"
-    if Pkg::Util.ask_yes_or_no
-      extra_flags = ['--ignore-existing', '--delay-updates']
-      extra_flags << '--dry-run' if ENV['DRYRUN']
-
-      staged_pkgs.each do |pkg|
-        Pkg::Util::Execution.retry_on_fail(times: 3) do
-          sub_string = 'pkg'
-          remote_pkg = pkg.sub(sub_string, remote_path)
-          remote_basepath = File.dirname(remote_pkg)
-          Pkg::Util::Net.remote_execute(staging_server, "mkdir -p #{remote_basepath}")
-          Pkg::Util::Net.rsync_to(
-            File.join(tmpdir, pkg),
-            staging_server,
-            remote_basepath,
-            extra_flags: extra_flags
-          )
-
-          Pkg::Util::Net.remote_set_ownership(staging_server, 'root', 'release', [remote_basepath, remote_pkg])
-          Pkg::Util::Net.remote_set_permissions(staging_server, '775', [remote_basepath])
-          Pkg::Util::Net.remote_set_permissions(staging_server, '0664', [remote_pkg])
-          Pkg::Util::Net.remote_set_immutable(staging_server, [remote_pkg]) if options[:chattr]
-        end
+    return false unless Pkg::Util.ask_yes_or_no
+
+    extra_flags = %w(--ignore-existing --delay-updates)
+    extra_flags << '--dry-run' if ENV['DRYRUN']
+
+    staged_pkgs.each do |pkg|
+      Pkg::Util::Execution.retry_on_fail(times: 3) do
+        sub_string = 'pkg'
+        remote_pkg = pkg.sub(sub_string, remote_path)
+        remote_basepath = File.dirname(remote_pkg)
+        Pkg::Util::Net.remote_execute(staging_server, "mkdir -p #{remote_basepath}")
+        Pkg::Util::Net.rsync_to(
+          File.join(tmpdir, pkg),
+          staging_server,
+          remote_basepath,
+          extra_flags: extra_flags
+        )
+
+        Pkg::Util::Net.remote_set_ownership(
+          staging_server, 'root', 'release', [remote_basepath, remote_pkg]
+        )
+        Pkg::Util::Net.remote_set_permissions(staging_server, '775', [remote_basepath])
+        Pkg::Util::Net.remote_set_permissions(staging_server, '0664', [remote_pkg])
+        Pkg::Util::Net.remote_set_immutable(staging_server, [remote_pkg]) if options[:chattr]
       end
-      return true
     end
+    return true
   end
 
   def ship_rpms(local_staging_directory, remote_path, opts = {})
@@ -123,6 +133,8 @@ module Pkg::Util::Ship
     ship_pkgs(things_to_ship, Pkg::Config.apt_signing_server, remote_path, opts)
   end
 
+
+
   def ship_svr4(local_staging_directory, remote_path, opts = {})
     ship_pkgs(["#{local_staging_directory}/**/*.pkg.gz"], Pkg::Config.svr4_host, remote_path, opts)
   end
@@ -132,33 +144,63 @@ module Pkg::Util::Ship
   end
 
   def ship_dmg(local_staging_directory, remote_path, opts = {})
-    packages_have_shipped = ship_pkgs(["#{local_staging_directory}/**/*.dmg"],
-                                      Pkg::Config.dmg_staging_server, remote_path, opts)
-
-    if packages_have_shipped
-      Pkg::Platforms.platform_tags_for_package_format('dmg').each do |platform_tag|
-        # Create the latest symlink for the current supported repo
-        Pkg::Util::Net.remote_create_latest_symlink(
-          Pkg::Config.project,
-          Pkg::Paths.artifacts_path(platform_tag, remote_path, opts[:nonfinal]),
-          'dmg'
-        )
-      end
+    packages_have_shipped = ship_pkgs(
+      ["#{local_staging_directory}/**/*.dmg"],
+      Pkg::Config.dmg_staging_server, remote_path, opts
+    )
+
+    return unless packages_have_shipped
+
+    Pkg::Platforms.platform_tags_for_package_format('dmg').each do |platform_tag|
+      # Create the latest symlink for the current supported repo
+      Pkg::Util::Net.remote_create_latest_symlink(
+        Pkg::Config.project,
+        Pkg::Paths.artifacts_path(platform_tag, remote_path, opts[:nonfinal]),
+        'dmg'
+      )
     end
   end
 
   def ship_swix(local_staging_directory, remote_path, opts = {})
-    ship_pkgs(["#{local_staging_directory}/**/*.swix"], Pkg::Config.swix_staging_server, remote_path, opts)
+    ship_pkgs(
+      ["#{local_staging_directory}/**/*.swix"],
+      Pkg::Config.swix_staging_server,
+      remote_path,
+      opts
+    )
   end
 
   def ship_msi(local_staging_directory, remote_path, opts = {})
-    packages_have_shipped = ship_pkgs(["#{local_staging_directory}/**/*.msi"], Pkg::Config.msi_staging_server, remote_path, opts)
+    packages_have_shipped = ship_pkgs(
+      ["#{local_staging_directory}/**/*.msi"],
+      Pkg::Config.msi_staging_server,
+      remote_path,
+      opts
+    )
+    return unless packages_have_shipped
 
-    if packages_have_shipped
-      # Create the symlinks for the latest supported repo
-      Pkg::Util::Net.remote_create_latest_symlink(Pkg::Config.project, Pkg::Paths.artifacts_path(Pkg::Platforms.generic_platform_tag('windows'), remote_path, opts[:nonfinal]), 'msi', arch: 'x64')
-      Pkg::Util::Net.remote_create_latest_symlink(Pkg::Config.project, Pkg::Paths.artifacts_path(Pkg::Platforms.generic_platform_tag('windows'), remote_path, opts[:nonfinal]), 'msi', arch: 'x86')
-    end
+    # Create the symlinks for the latest supported repo
+    Pkg::Util::Net.remote_create_latest_symlink(
+      Pkg::Config.project,
+      Pkg::Paths.artifacts_path(
+        Pkg::Platforms.generic_platform_tag('windows'),
+        remote_path,
+        opts[:nonfinal]
+      ),
+      'msi',
+      arch: 'x64'
+    )
+
+    Pkg::Util::Net.remote_create_latest_symlink(
+      Pkg::Config.project,
+      Pkg::Paths.artifacts_path(
+        Pkg::Platforms.generic_platform_tag('windows'),
+        remote_path,
+        opts[:nonfinal]
+      ),
+      'msi',
+      arch: 'x86'
+    )
   end
 
   def ship_gem(local_staging_directory, remote_path, opts = {})
@@ -166,44 +208,32 @@ module Pkg::Util::Ship
   end
 
   def ship_tar(local_staging_directory, remote_path, opts = {})
-    ship_pkgs(["#{local_staging_directory}/*.tar.gz*"], Pkg::Config.tar_staging_server, remote_path, opts)
+    ship_pkgs(
+      ["#{local_staging_directory}/*.tar.gz*"],
+      Pkg::Config.tar_staging_server,
+      remote_path,
+      opts
+    )
   end
 
   def rolling_repo_link_command(platform_tag, repo_path, nonfinal = false)
-    base_path, link_path = Pkg::Paths.artifacts_base_path_and_link_path(platform_tag, repo_path, nonfinal)
+    base_path, link_path = Pkg::Paths.artifacts_base_path_and_link_path(
+      platform_tag,
+      repo_path,
+      nonfinal
+    )
 
     if link_path.nil?
       puts "No link target set, not creating rolling repo link for #{base_path}"
       return nil
     end
-
-    cmd = <<-CMD
-      if [ ! -d #{base_path} ] ; then
-        echo "Link target '#{base_path}' does not exist; skipping"
-        exit 0
-      fi
-      # If it's a link but pointing to the wrong place, remove the link
-      # This is likely to happen around the transition times, like puppet5 -> puppet6
-      if [ -L #{link_path} ] && [ ! #{base_path} -ef #{link_path} ] ; then
-        rm #{link_path}
-      # This is the link you're looking for, nothing to see here
-      elif [ -L #{link_path} ] ; then
-        exit 0
-      # Don't want to delete it if it isn't a link, that could be destructive
-      # So, fail!
-      elif [ -e #{link_path} ] ; then
-        echo "#{link_path} exists but isn't a link, I don't know what to do with this" >&2
-        exit 1
-      fi
-      ln -s #{base_path} #{link_path}
-    CMD
   end
 
   def create_rolling_repo_link(platform_tag, staging_server, repo_path, nonfinal = false)
     command = rolling_repo_link_command(platform_tag, repo_path, nonfinal)
 
     Pkg::Util::Net.remote_execute(staging_server, command) unless command.nil?
-  rescue => e
+  rescue StandardError => e
     fail "Failed to create rolling repo link for '#{platform_tag}'.\n#{e}\n#{e.backtrace}"
   end
 
@@ -214,10 +244,33 @@ module Pkg::Util::Ship
     swix_path = Pkg::Paths.remote_repo_base(nonfinal: nonfinal, package_format: 'swix')
     msi_path = Pkg::Paths.remote_repo_base(nonfinal: nonfinal, package_format: 'msi')
 
-    create_rolling_repo_link(Pkg::Platforms.generic_platform_tag('el'), Pkg::Config.yum_staging_server, yum_path, nonfinal)
-    create_rolling_repo_link(Pkg::Platforms.generic_platform_tag('osx'), Pkg::Config.dmg_staging_server, dmg_path, nonfinal)
-    create_rolling_repo_link(Pkg::Platforms.generic_platform_tag('eos'), Pkg::Config.swix_staging_server, swix_path, nonfinal)
-    create_rolling_repo_link(Pkg::Platforms.generic_platform_tag('windows'), Pkg::Config.msi_staging_server, msi_path, nonfinal)
+    create_rolling_repo_link(
+      Pkg::Platforms.generic_platform_tag('el'),
+      Pkg::Config.yum_staging_server,
+      yum_path,
+      nonfinal
+    )
+
+    create_rolling_repo_link(
+      Pkg::Platforms.generic_platform_tag('osx'),
+      Pkg::Config.dmg_staging_server,
+      dmg_path,
+      nonfinal
+    )
+
+    create_rolling_repo_link(
+      Pkg::Platforms.generic_platform_tag('eos'),
+      Pkg::Config.swix_staging_server,
+      swix_path,
+      nonfinal
+    )
+
+    create_rolling_repo_link(
+      Pkg::Platforms.generic_platform_tag('windows'),
+      Pkg::Config.msi_staging_server,
+      msi_path,
+      nonfinal
+    )
 
     # 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
@@ -231,7 +284,12 @@ module Pkg::Util::Ship
       apt_path = Pkg::Config.nonfinal_apt_repo_staging_path
     end
     Pkg::Platforms.codenames.each do |codename|
-      create_rolling_repo_link(Pkg::Platforms.codename_to_tags(codename)[0], Pkg::Config.apt_signing_server, apt_path, nonfinal)
+      create_rolling_repo_link(
+        Pkg::Platforms.codename_to_tags(codename)[0],
+        Pkg::Config.apt_signing_server,
+        apt_path,
+        nonfinal
+      )
     end
   end
 
@@ -297,4 +355,151 @@ module Pkg::Util::Ship
     end
     Rake::Task[ship_task].invoke
   end
+
+  # Ship pkg directory contents to distribution server
+  def ship(target = 'artifacts', local_directory = 'pkg')
+    Pkg::Util::File.fetch
+
+    unless Pkg::Config.project
+      fail "You must set the 'project' in build_defaults.yaml or with the 'PROJECT_OVERRIDE' environment variable."
+    end
+
+    project_basedir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}"
+    artifact_directory = "#{project_basedir}/#{target}"
+
+    # For EZBake builds, we also want to include the ezbake.manifest file to
+    # get a snapshot of this build and all dependencies. We eventually will
+    # create a yaml version of this file, but until that point we want to
+    # make the original ezbake.manifest available
+    #
+    ezbake_manifest = File.join('ext', 'ezbake.manifest')
+    if File.exist?(ezbake_manifest)
+      FileUtils.cp(ezbake_manifest, File.join(local_directory, "#{Pkg::Config.ref}.ezbake.manifest"))
+    end
+    ezbake_yaml = File.join("ext", "ezbake.manifest.yaml")
+    if File.exists?(ezbake_yaml)
+      FileUtils.cp(ezbake_yaml, File.join(local_directory, "#{Pkg::Config.ref}.ezbake.manifest.yaml"))
+    end
+
+    # Inside build_metadata*.json files there is additional metadata containing
+    # information such as git ref and dependencies that are needed at build
+    # time. If these files exist, copy them downstream.
+    # Typically these files are named 'ext/build_metadata.<project>.<platform>.json'
+    build_metadata_json_files = Dir.glob('ext/build_metadata*.json')
+    build_metadata_json_files.each do |source_file|
+      target_file = File.join(local_directory, "#{Pkg::Config.ref}.#{File.basename(source_file)}")
+      FileUtils.cp(source_file, target_file)
+    end
+
+    # Sadly, the packaging repo cannot yet act on its own, without living
+    # inside of a packaging-repo compatible project. This means in order to
+    # use the packaging repo for shipping and signing (things that really
+    # don't require build automation, specifically) we still need the project
+    # clone itself.
+    Pkg::Util::Git.bundle('HEAD', 'signing_bundle', local_directory)
+
+    # 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 = ''
+      Dir.chdir(PACKAGING_ROOT) do
+        packaging_bundle = Pkg::Util::Git.bundle('HEAD', 'packaging-bundle')
+      end
+      FileUtils.mv(packaging_bundle, local_directory)
+    end
+
+    # This is functionality to add the project-arch.msi links that have no
+    # version. The code itself looks for the link (if it's there already)
+    # and if the source package exists before linking. Searching for the
+    # packages has been restricted specifically to just the pkg/windows dir
+    # on purpose, as this is where we currently have all windows packages
+    # building to. Once we move the Metadata about the output location in
+    # to one source of truth we can refactor this to use that to search
+    #                                           -Sean P. M. 08/12/16
+
+    {
+      'windows' => ['x86', 'x64'],
+      'windowsfips' => ['x64']
+    }.each_pair do |platform, archs|
+      packages = Dir["#{local_directory}/#{platform}/*"]
+
+      archs.each do |arch|
+        package_version = Pkg::Util::Git.describe.tr('-', '.')
+        package_filename = File.join(local_directory, platform, "#{Pkg::Config.project}-#{package_version}-#{arch}.msi")
+        link_filename = File.join(local_directory, platform, "#{Pkg::Config.project}-#{arch}.msi")
+
+        next unless !packages.include?(link_filename) && packages.include?(package_filename)
+        # Dear future code spelunkers:
+        # Using symlinks instead of hard links causes failures when we try
+        # to set these files to be immutable. Also be wary of whether the
+        # linking utility you're using expects the source path to be relative
+        # to the link target or pwd.
+        #
+        FileUtils.ln(package_filename, link_filename)
+      end
+    end
+
+    Pkg::Util::Execution.retry_on_fail(times: 3) do
+      Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir --mode=775 -p #{project_basedir}")
+      Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir -p #{artifact_directory}")
+      Pkg::Util::Net.rsync_to("#{local_directory}/", Pkg::Config.distribution_server, "#{artifact_directory}/", extra_flags: ['--ignore-existing', '--exclude repo_configs'])
+    end
+
+    # 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
+    #
+    Pkg::Config.config_to_yaml(local_directory)
+    Pkg::Util::Execution.retry_on_fail(:times => 3) do
+      Pkg::Util::Net.rsync_to("#{local_directory}/#{Pkg::Config.ref}.yaml", Pkg::Config.distribution_server, "#{artifact_directory}/", extra_flags: ["--exclude repo_configs"])
+    end
+
+    # If we just shipped a tagged version, we want to make it immutable
+    files = Dir.glob("#{local_directory}/**/*").select { |f| File.file?(f) and !f.include? "#{Pkg::Config.ref}.yaml" }.map do |file|
+      "#{artifact_directory}/#{file.sub(/^#{local_directory}\//, '')}"
+    end
+
+    Pkg::Util::Net.remote_set_ownership(Pkg::Config.distribution_server, 'root', 'release', files)
+    Pkg::Util::Net.remote_set_permissions(Pkg::Config.distribution_server, '0664', files)
+    Pkg::Util::Net.remote_set_immutable(Pkg::Config.distribution_server, files)
+  end
+
+  def ship_to_artifactory(local_directory = 'pkg')
+    Pkg::Util::File.fetch
+    unless Pkg::Config.project
+      fail "You must set the 'project' in build_defaults.yaml or with the 'PROJECT_OVERRIDE' environment variable."
+    end
+    artifactory = Pkg::ManageArtifactory.new(Pkg::Config.project, Pkg::Config.ref)
+
+    artifacts = Dir.glob("#{local_directory}/**/*").reject { |e| File.directory? e }
+    artifacts.sort! do |a, b|
+      if File.extname(a) =~ /(md5|sha\d+)/ && File.extname(b) !~ /(md5|sha\d+)/
+        1
+      elsif File.extname(b) =~ /(md5|sha\d+)/ && File.extname(a) !~ /(md5|sha\d+)/
+        -1
+      else
+        a <=> b
+      end
+    end
+    artifacts.each do |artifact|
+      if File.extname(artifact) == ".yaml" || File.extname(artifact) == ".json"
+        artifactory.deploy_package(artifact)
+      elsif artifactory.package_exists_on_artifactory?(artifact)
+        warn "Attempt to upload '#{artifact}' failed. Package already exists!"
+      else
+        artifactory.deploy_package(artifact)
+      end
+    end
+  end
 end

data/lib/packaging/util/sign.rb

@@ -0,0 +1,47 @@
+# Module for signing all packages to places
+
+
+module Pkg::Util::Sign
+  class << self
+    # Sign all locally staged packages on signing server.
+    def sign_all(root_directory = nil)
+      Pkg::Util::File.fetch
+      root_directory ||= ENV['DEFAULT_DIRECTORY']
+      Dir["#{root_directory}/*"].empty? and fail "There were no files found in #{root_directory}. \
+      Maybe you wanted to build/retrieve something first?"
+
+      # Because rpms and debs are laid out differently in PE under pkg/ they
+      # have a different sign task to address this. Rather than create a whole
+      # extra :jenkins task for signing PE, we determine which sign task to use
+      # based on if we're building PE.
+      # We also listen in on the environment variable SIGNING_BUNDLE. This is
+      # _NOT_ intended for public use, but rather with the internal promotion
+      # workflow for Puppet Enterprise. SIGNING_BUNDLE is the path to a tarball
+      # containing a git bundle to be used as the environment for the packaging
+      # repo in a signing operation.
+      signing_bundle = ENV['SIGNING_BUNDLE']
+      sign_tasks    = ["pl:sign_rpms"]
+      sign_tasks    << "pl:sign_deb_changes" unless Dir["#{root_directory}/**/*.changes"].empty?
+      sign_tasks    << "pl:sign_tar" if Pkg::Config.build_tar
+      sign_tasks    << "pl:sign_gem" if Pkg::Config.build_gem
+      sign_tasks    << "pl:sign_osx" if Pkg::Config.build_dmg || Pkg::Config.vanagon_project
+      sign_tasks    << "pl:sign_swix" if Pkg::Config.vanagon_project
+      sign_tasks    << "pl:sign_svr4" if Pkg::Config.vanagon_project
+      sign_tasks    << "pl:sign_ips" if Pkg::Config.vanagon_project
+      sign_tasks    << "pl:sign_msi" if Pkg::Config.build_msi || Pkg::Config.vanagon_project
+      remote_repo   = Pkg::Util::Net.remote_unpack_git_bundle(Pkg::Config.signing_server, 'HEAD', nil, signing_bundle)
+      build_params  = Pkg::Util::Net.remote_buildparams(Pkg::Config.signing_server, Pkg::Config)
+      Pkg::Util::Net.rsync_to(root_directory, Pkg::Config.signing_server, remote_repo)
+      rake_command = <<-DOC
+cd #{remote_repo} ;
+#{Pkg::Util::Net.remote_bundle_install_command}
+bundle exec rake #{sign_tasks.map { |task| task + "[#{root_directory}]" }.join(" ")} PARAMS_FILE=#{build_params}
+DOC
+      Pkg::Util::Net.remote_execute(Pkg::Config.signing_server, rake_command)
+      Pkg::Util::Net.rsync_from("#{remote_repo}/#{root_directory}/", Pkg::Config.signing_server, "#{root_directory}/")
+      Pkg::Util::Net.remote_execute(Pkg::Config.signing_server, "rm -rf #{remote_repo}")
+      Pkg::Util::Net.remote_execute(Pkg::Config.signing_server, "rm #{build_params}")
+      puts "Signed packages staged in #{root_directory}/ directory"
+    end
+  end
+end

data/lib/packaging/util/windows.rb

@@ -0,0 +1,38 @@
+# Utility methods for handling windows
+
+require 'fileutils'
+
+module Pkg::Util::Windows
+  class << self
+    def add_msi_links(local_source_directory)
+      {
+        'windows' => ['x86', 'x64'],
+        'windowsfips' => ['x64']
+      }.each_pair do |platform, archs|
+        packages = Dir["#{local_source_directory}/#{platform}/*"]
+
+        archs.each do |arch|
+          package_version = Pkg::Util::Git.describe.tr('-', '.')
+          package_filename = File.join(
+            local_source_directory, platform,
+            "#{Pkg::Config.project}-#{package_version}-#{arch}.msi"
+          )
+          link_filename = File.join(
+            local_source_directory,
+            platform,
+            "#{Pkg::Config.project}-#{arch}.msi"
+          )
+
+          next unless !packages.include?(link_filename) && packages.include?(package_filename)
+
+          # Dear future code spelunkers:
+          # Using symlinks instead of hard links causes failures when we try
+          # to set these files to be immutable. Also be wary of whether the
+          # linking utility you're using expects the source path to be relative
+          # to the link target or pwd.
+          FileUtils.ln(package_filename, link_filename)
+        end
+      end
+    end
+  end
+end

data/lib/packaging/util.rb

@@ -4,8 +4,12 @@ module Pkg::Util
   require 'benchmark'
   require 'base64'
   require 'io/console'
+  require 'packaging/util/apt_staging_server'
+  require 'packaging/util/build_metadata'
   require 'packaging/util/date'
+  require 'packaging/util/distribution_server'
   require 'packaging/util/execution'
+  require 'packaging/util/ezbake'
   require 'packaging/util/file'
   require 'packaging/util/git'
   require 'packaging/util/gpg'
@@ -19,7 +23,10 @@ module Pkg::Util
   require 'packaging/util/tool'
   require 'packaging/util/rake_utils'
   require 'packaging/util/version'
+  require 'packaging/util/windows'
   require 'packaging/util/git_tags'
+  require 'packaging/util/sign'
+  require 'packaging/util/repo'
 
   def self.boolean_value(var)
     return true if var == true || ( var.is_a?(String) && ( var.downcase == 'true' || var.downcase =~ /^y$|^yes$/))

data/spec/lib/packaging/config_spec.rb

@@ -223,7 +223,7 @@ describe "Pkg::Config" do
       "./artifacts/aix/7.1/PC1/ppc/puppet-agent-5.3.2-1.aix7.1.ppc.rpm"
 
     fedora_artifacts = \
-      "./artifacts/fedora/31/PC1/x86_64/puppet-agent-5.3.2-1.fc31.x86_64.rpm"
+      "./artifacts/fedora/32/PC1/x86_64/puppet-agent-5.3.2-1.fc32.x86_64.rpm"
 
     windows_artifacts = \
       "./artifacts/windows/puppet-agent-x64.msi\n" \
@@ -280,8 +280,8 @@ describe "Pkg::Config" do
     it "should not use 'f' in fedora platform tags" do
       allow(Pkg::Util::Net).to receive(:remote_execute).and_return(fedora_artifacts, nil)
       data = Pkg::Config.platform_data
-      expect(data).to include('fedora-31-x86_64')
-      expect(data).not_to include('fedora-f31-x86_64')
+      expect(data).to include('fedora-32-x86_64')
+      expect(data).not_to include('fedora-f32-x86_64')
     end
 
     it "should collect packages whose extname differ from package_format" do

data/spec/lib/packaging/deb/repo_spec.rb

@@ -6,7 +6,7 @@ describe "Pkg::Deb::Repo" do
   let(:project)       { "deb_repos" }
   let(:ref)           { "1234abcd" }
   let(:base_url)      { "http://#{builds_server}/#{project}/#{ref}" }
-  let(:cows)          { ["xenial", "jessie", "trusty", "stretch", ""] }
+  let(:cows)          { ["xenial", "trusty", "stretch", ""] }
   let(:wget_results)  { cows.map {|cow| "#{base_url}/repos/apt/#{cow}" }.join("\n") }
   let(:wget_garbage)  { "\n and an index\nhttp://somethingelse.com/robots" }
   let(:repo_configs)  { cows.reject {|cow| cow.empty?}.map {|dist| "pkg/repo_configs/deb/pl-#{project}-#{ref}-#{dist}.list" } }

data/spec/lib/packaging/paths_spec.rb

@@ -5,12 +5,11 @@ describe 'Pkg::Paths' do
     arch_transformations = {
       ['pkg/el-8-x86_64/puppet-agent-6.9.0-1.el8.x86_64.rpm', 'el', '8'] => 'x86_64',
       ['pkg/el/8/puppet6/aarch64/puppet-agent-6.5.0.3094.g16b6fa6f-1.el8.aarch64.rpm', 'el', '8'] => 'aarch64',
-      ['artifacts/fedora/32/puppet6/x86_64/puppet-agent-6.9.0-1.fc30.x86_64.rpm', 'fedora', '32'] => 'x86_64',
+      ['artifacts/fedora/32/puppet6/x86_64/puppet-agent-6.9.0-1.fc32.x86_64.rpm', 'fedora', '32'] => 'x86_64',
       ['pkg/ubuntu-16.04-amd64/puppet-agent_4.99.0-1xenial_amd64.deb', 'ubuntu', '16.04'] => 'amd64',
       ['artifacts/deb/focal/puppet6/puppet-agent_6.5.0.3094.g16b6fa6f-1focal_arm64.deb', 'ubuntu', '20.04'] => 'aarch64',
 
       ['artifacts/ubuntu-16.04-i386/puppetserver_5.0.1-0.1SNAPSHOT.2017.07.27T2346puppetlabs1.debian.tar.gz', 'ubuntu', '16.04'] => 'source',
-      ['artifacts/deb/jessie/PC1/puppetserver_5.0.1.master.orig.tar.gz', 'debian', '8'] => 'source',
       ['artifacts/el/6/PC1/SRPMS/puppetserver-5.0.1.master-0.1SNAPSHOT.2017.08.18T0951.el6.src.rpm', 'el', '6'] => 'SRPMS'
     }
     arch_transformations.each do |path_array, arch|
@@ -273,7 +272,7 @@ describe 'Pkg::Paths' do
         .to eq(fake_apt_repo_path)
     end
     it 'returns nonfinal_yum_repo_path for nonfinal rpms' do
-      expect(Pkg::Paths.remote_repo_base('fedora-31-x86_64', nonfinal: true))
+      expect(Pkg::Paths.remote_repo_base('fedora-34-x86_64', nonfinal: true))
         .to eq(fake_yum_nightly_repo_path)
     end
     it 'returns nonfinal_apt_repo_path for nonfinal debs' do

data/spec/lib/packaging/platforms_spec.rb

@@ -26,7 +26,7 @@ describe 'Pkg::Platforms' do
 
   describe '#versions_for_platform' do
     it 'should return all supported versions for a given platform' do
-      expect(Pkg::Platforms.versions_for_platform('el')).to match_array(['5', '6', '7', '8'])
+      expect(Pkg::Platforms.versions_for_platform('el')).to match_array(['6', '7', '8', '9'])
     end
 
     it 'should raise an error if given a nonexistent platform' do
@@ -36,7 +36,7 @@ describe 'Pkg::Platforms' do
 
   describe '#codenames' do
     it 'should return all codenames for a given platform' do
-      codenames = ['focal', 'bionic', 'bullseye', 'buster', 'cosmic', 'jessie', 'stretch', 'trusty', 'xenial']
+      codenames = ['focal', 'bionic', 'bullseye', 'buster', 'stretch', 'trusty', 'xenial']
       expect(Pkg::Platforms.codenames).to match_array(codenames)
     end
   end
@@ -101,12 +101,12 @@ describe 'Pkg::Platforms' do
       it 'should return a hash of platform info' do
         expect(Pkg::Platforms.platform_lookup(platform)).to be_instance_of(Hash)
       end
-  
+
       it 'should include at least arch and package format keys' do
         expect(Pkg::Platforms.platform_lookup(platform).keys).to include(:architectures)
         expect(Pkg::Platforms.platform_lookup(platform).keys).to include(:package_format)
       end
-    end 
+    end
   end
 
   describe '#get_attribute' do
@@ -166,7 +166,7 @@ describe 'Pkg::Platforms' do
 
   describe '#generic_platform_tag' do
     it 'fails for unsupported platforms' do
-      expect { Pkg::Platforms.generic_platform_tag('butts') }.to raise_error
+      expect { Pkg::Platforms.generic_platform_tag('noplatform') }.to raise_error
     end
 
     it 'returns a supported platform tag containing the supplied platform' do