packaging 0.99.80 → 0.102.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c641cdc322d55fe7c595fb4802ababf87830fe6a63a852f3acf291b601deeed
-  data.tar.gz: 39d19f13de74f2736b3aa8efcd9519345a81ee056f33ae7f1960cecc40e7d896
+  metadata.gz: f8109d6dfa1a7f7e43f5ecf91242eef84cdf835e787332330edf69a72575964a
+  data.tar.gz: 3e7758f0d7aa68dda7ba93496fd3560d8a89fcadb90945009f3637bfe36df293
 SHA512:
-  metadata.gz: 690143636f97cba9f3a97918c60dd1f875b2b0a84eada68ae456f3b7c71a0295fcf38fcafcaf1584237ce2dbec6b3c4c8350e4e0d4112ac60f5c1f057ddd27ed
-  data.tar.gz: 3cfd026361b7b485eaffc9e9bb1ec8c0a2a296300631d3399f9edb3ee8d2e59a4cf3866cd0f1f7243f70f9ff15b3dc2b372477426ebf55fe5657362f531a76c9
+  metadata.gz: 6d6c20e9875ac5f178dd5fa1f819eb179d853e85097cc5ea322918ee57dfed229bd02fa8d4f89fd19db4a06a4633d13bde6103d69d524bbbb62af5f67461b90f
+  data.tar.gz: d8765d30cc28d2001766cc9705333594d14f39053e4a3fab9c38763be812ec7a4ceeb783c9c44593b9a6a0852129ebb391c5ec057cddfe250d7274524f5ed9d9

data/lib/packaging/artifactory.rb

@@ -342,40 +342,69 @@ module Pkg
       end
     end
 
-    # Using the manifest provided by enterprise-dist, grab the appropropriate packages from artifactory based on md5sum
+    # Using the manifest provided by enterprise-dist, grab the
+    # appropropriate packages from artifactory based on md5sum
+
     # @param staging_directory [String] location to download packages to
-    # @param manifest [File] JSON file containing information about what packages to download and the corresponding md5sums
+    # @param manifest [File] JSON file listing which packages to download and
+    #   the corresponding md5sums
     # @param remote_path [String] Optional partial path on the remote host containing packages
     #        Used to specify which subdirectories packages will be downloaded from.
     def download_packages(staging_directory, manifest, remote_path = '')
       check_authorization
+      download_repositories = %w(rpm_enterprise__local debian_enterprise__local)
       manifest.each do |dist, packages|
-        puts "Grabbing the #{dist} packages from artifactory"
         packages.each do |name, info|
-          filename = info['filename']
-          artifacts = Artifactory::Resource::Artifact.checksum_search(md5: "#{info["md5"]}", repos: ["rpm_enterprise__local", "debian_enterprise__local"], name: filename)
-          artifact_to_download = artifacts.select { |artifact| artifact.download_uri.include? remote_path }.first
-          # If we found matching artifacts, but not in the correct path, copy the artifact to the correct path
-          # This should help us keep repos up to date with the packages we are expecting to be there
-          # while helping us avoid 'what the hell, could not find package' errors
+          package_file_name = info['filename']
+          puts format(
+                 "Searching Artifactory [%s]%s for %s (md5: %s)",
+                 download_repositories.join(', '),
+                 remote_path.empty? ? '' : "/#{remote_path}",
+                 package_file_name,
+                 info['md5']
+               )
+          artifacts = Artifactory::Resource::Artifact.checksum_search(
+            md5: info['md5'],
+            repos: download_repositories,
+            name: package_file_name
+          )
+
+          artifact_to_download = artifacts.select do |artifact|
+            artifact.download_uri.include? remote_path
+          end.first
+
+          # If we found matching artifacts, but not in the correct
+          # path, copy the artifact to the correct path This should
+          # help us keep repos up to date with the packages we are
+          # expecting to be there while helping us avoid 'could not
+          # find package' errors
           if artifact_to_download.nil? && !artifacts.empty?
             artifact_to_copy = artifacts.first
-            copy_artifact(artifact_to_copy, artifact_to_copy.repo, "#{remote_path}/#{dist}/#{filename}")
-            artifacts = Artifactory::Resource::Artifact.checksum_search(md5: "#{info["md5"]}", repos: ["rpm_enterprise__local", "debian_enterprise__local"], name: filename)
-            artifact_to_download = artifacts.select { |artifact| artifact.download_uri.include? remote_path }.first
+            copy_artifact(artifact_to_copy, artifact_to_copy.repo,
+                          "#{remote_path}/#{dist}/#{package_file_name}")
+
+            # Now, search again to make sure we find them in the correct path.
+            artifacts = Artifactory::Resource::Artifact.checksum_search(
+              md5: info['md5'],
+              repos: download_repositories,
+              name: package_file_name
+            )
+            artifact_to_download = artifacts.select do |artifact|
+              artifact.download_uri.include? remote_path
+            end.first
           end
 
           if artifact_to_download.nil?
-            message = "Error: what the hell, could not find package #{filename} with md5sum #{info["md5"]}"
-            unless remote_path.empty?
-              message += " in #{remote_path}"
-            end
+            message = "Error: could not find package #{package_file_name} " \
+                      "with md5sum #{info['md5']}"
+            message += " in #{remote_path}" unless remote_path.empty?
             raise message
-          else
-            full_staging_path = "#{staging_directory}/#{dist}"
-            puts "downloading #{artifact_to_download.download_uri} to #{File.join(full_staging_path, filename)}"
-            artifact_to_download.download(full_staging_path, filename: filename)
           end
+
+          full_staging_path = "#{staging_directory}/#{dist}"
+          puts "Downloading #{artifact_to_download.download_uri} to " \
+               "#{File.join(full_staging_path, package_file_name)}"
+          artifact_to_download.download(full_staging_path, filename: package_file_name)
         end
       end
     end

data/lib/packaging/config.rb

@@ -80,7 +80,7 @@ module Pkg
 
         dir = "/opt/jenkins-builds/#{self.project}/#{self.ref}"
         cmd = "if [ -s \"#{dir}/artifacts\" ]; then cd #{dir};"\
-              "find ./artifacts/ -mindepth 2 -type f; fi"
+              "find ./artifacts -mindepth 2 -type f; fi"
         artifacts, _ = Pkg::Util::Net.remote_execute(
                      self.builds_server,
                      cmd,
@@ -95,6 +95,7 @@ module Pkg
           # the correct place. For 5.x and 6.x release streams the f prefix
           # has been removed and so tag will equal original_tag
           original_tag = Pkg::Paths.tag_from_artifact_path(artifact)
+          fail "Error: unrecognized artifact \"#{artifact}\"" if original_tag.nil?
 
           # Remove the f-prefix from the fedora platform tag keys so that
           # beaker can rely on consistent keys once we rip out the f for good
@@ -203,15 +204,18 @@ module Pkg
       # string. Accept an argument for the write target file. If not specified,
       # the name of the params file is the current git commit sha or tag.
       #
-      def config_to_yaml(target = nil)
-        file = "#{self.ref}.yaml"
-        target = target.nil? ? File.join(Pkg::Util::File.mktemp, "#{self.ref}.yaml") : File.join(target, file)
-        Pkg::Util::File.file_writable?(File.dirname(target), :required => true)
-        File.open(target, 'w') do |f|
+      def config_to_yaml(destination_directory = nil)
+        destination_directory = Pkg::Util::File.mktemp if destination_directory.nil?
+        config_yaml_file_name = "#{self.ref}.yaml"
+
+        config_yaml_path = File.join(destination_directory, config_yaml_file_name)
+
+        Pkg::Util::File.file_writable?(File.dirname(config_yaml_path), :required => true)
+        File.open(config_yaml_path, 'w') do |f|
           f.puts self.config_to_hash.to_yaml
         end
-        puts target
-        target
+        puts config_yaml_path
+        return config_yaml_path
       end
 
       ##

data/lib/packaging/platforms.rb

@@ -157,6 +157,14 @@ module Pkg
           source_package_formats: ['src.rpm'],
           signature_format: 'v3',
           repo: true,
+        },
+        '8' => {
+          architectures: ['x86_64'],
+          source_architecture: 'SRPMS',
+          package_format: 'rpm',
+          source_package_formats: ['src.rpm'],
+          signature_format: 'v3',
+          repo: true,
         }
       },
 

data/lib/packaging/repo.rb

@@ -36,7 +36,8 @@ module Pkg::Repo
       Dir.chdir(File.join('pkg', local_target)) do
         puts "Info: Archiving #{repo_location} as #{archive_name}"
         target_tarball = File.join('repos', "#{archive_name}.tar.gz")
-        tar_command = "#{tar} --owner=0 --group=0 --create --gzip --file #{target_tarball} #{repo_location}"
+        tar_command = %W[#{tar} --owner=0 --group=0 --create --gzip
+          --file #{target_tarball} #{repo_location}].join(' ')
         stdout, _, _ = Pkg::Util::Execution.capture3(tar_command)
         return stdout
       end
@@ -62,12 +63,12 @@ module Pkg::Repo
           next
         end
 
-        tar_action = "--create"
-        if File.exist?(all_repos_tarball_name)
-          tar_action = "--update"
-        end
+        tar_action = '--create'
+        tar_action = '--update' if File.exist?(all_repos_tarball_name)
+
+        tar_command = %W[#{tar} --owner=0 --group=0 #{tar_action}
+          --file #{all_repos_tarball_name} #{repo_tarball_path}].join(' ')
 
-        tar_command = "#{tar} --owner=0 --group=0 #{tar_action} --file #{all_repos_tarball_name} #{repo_tarball_path}"
         stdout, _, _ = Pkg::Util::Execution.capture3(tar_command)
         puts stdout
       end
@@ -117,7 +118,8 @@ module Pkg::Repo
               )
       return stdout.split
     rescue => e
-      fail "Error: Could not retrieve directories that contain #{pkg_ext} packages in #{Pkg::Config.distribution_server}:#{artifact_directory}"
+      fail "Error: Could not retrieve directories that contain #{pkg_ext} " \
+           "packages in #{Pkg::Config.distribution_server}:#{artifact_directory}: #{e}"
     end
 
     def populate_repo_directory(artifact_parent_directory)
@@ -126,7 +128,8 @@ module Pkg::Repo
       cmd << 'rsync --archive --verbose --one-file-system --ignore-existing artifacts/ repos/ '
       Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, cmd)
     rescue => e
-      fail "Error: Could not populate repos directory in #{Pkg::Config.distribution_server}:#{artifact_parent_directory}"
+      fail "Error: Could not populate repos directory in " \
+           "#{Pkg::Config.distribution_server}:#{artifact_parent_directory}: #{e}"
     end
 
     def argument_required?(argument_name, repo_command)
@@ -134,12 +137,12 @@ module Pkg::Repo
     end
 
     def update_repo(remote_host, command, options = {})
-      fail_message = "Error: Missing required argument '%s', update your build_defaults?"
+      fail_message = "Error: Missing required argument '%s', perhaps update build_defaults?"
       [:repo_name, :repo_path, :repo_host, :repo_url].each do |option|
         fail fail_message % option.to_s if argument_required?(option.to_s, command) && !options[option]
       end
 
-      whitelist = {
+      repo_configuration = {
         __REPO_NAME__: options[:repo_name],
         __REPO_PATH__: options[:repo_path],
         __REPO_HOST__: options[:repo_host],
@@ -149,7 +152,7 @@ module Pkg::Repo
       }
       Pkg::Util::Net.remote_execute(
         remote_host,
-        Pkg::Util::Misc.search_and_replace(command, whitelist))
+        Pkg::Util::Misc.search_and_replace(command, repo_configuration))
     end
   end
 end

data/lib/packaging/util/apt_staging_server.rb

@@ -0,0 +1,8 @@
+# Utility methods for handling Apt staging server.
+
+module Pkg::Util::AptStagingServer
+  def self.send_packages(pkg_directory, apt_component = 'stable')
+    %x(apt-stage-artifacts --component=#{apt_component} #{pkg_directory})
+    fail 'APT artifact staging failed.' unless $CHILD_STATUS.success?
+  end
+end

data/lib/packaging/util/build_metadata.rb

@@ -0,0 +1,17 @@
+# Utility methods for handling miscellaneous build metadata
+
+require 'fileutils'
+
+module Pkg::Util::BuildMetadata
+  class << self
+    def add_misc_json_files(target_directory)
+      misc_json_files = Dir.glob('ext/build_metadata*.json')
+      misc_json_files.each do |source_file|
+        target_file = File.join(
+          target_directory, "#{Pkg::Config.ref}.#{File.basename(source_file)}"
+        )
+        FileUtils.cp(source_file, target_file)
+      end
+    end
+  end
+end

data/lib/packaging/util/distribution_server.rb

@@ -0,0 +1,42 @@
+# Utility methods for the older distribution server
+
+require 'fileutils'
+
+module Pkg::Util::DistributionServer
+  class << self
+    def send_packages(local_source_directory, remote_target_directory)
+      Pkg::Util::Execution.retry_on_fail(times: 3) do
+        Pkg::Util::Net.remote_execute(
+          Pkg::Config.distribution_server,
+          "mkdir --mode=775 --parents #{remote_target_directory}"
+        )
+        Pkg::Util::Net.rsync_to(
+          "#{local_source_directory}/",
+          Pkg::Config.distribution_server, "#{remote_target_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_source_directory)
+      Pkg::Util::Execution.retry_on_fail(times: 3) do
+        Pkg::Util::Net.rsync_to(
+          "#{local_source_directory}/#{Pkg::Config.ref}.yaml",
+          Pkg::Config.distribution_server, "#{remote_target_directory}/",
+          extra_flags: ["--exclude repo_configs"]
+        )
+      end
+
+      # If we just shipped a tagged version, we want to make it immutable
+      files = Dir.glob("#{local_source_directory}/**/*")
+                 .select { |f| File.file?(f) and !f.include? "#{Pkg::Config.ref}.yaml" }
+                 .map { |f| "#{remote_target_directory}/#{f.sub(/^#{local_source_directory}\//, '')}" }
+
+      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
+  end
+end

data/lib/packaging/util/ezbake.rb

@@ -0,0 +1,26 @@
+# Utility methods for handling ezbake
+
+require 'fileutils'
+
+module Pkg::Util::EZbake
+  class << self
+    def add_manifest(target_directory)
+      ezbake_manifest = File.join('ext', 'ezbake.manifest')
+      ezbake_yaml = File.join('ext', 'ezbake.manifest.yaml')
+
+      if File.exist?(ezbake_manifest)
+        FileUtils.cp(
+          ezbake_manifest,
+          File.join(target_directory, "#{Pkg::Config.ref}.ezbake.manifest")
+        )
+      end
+
+      if File.exists?(ezbake_yaml)
+        FileUtils.cp(
+          ezbake_yaml,
+          File.join(target_directory, "#{Pkg::Config.ref}.ezbake.manifest.yaml")
+        )
+      end
+    end
+  end
+end

data/lib/packaging/util/net.rb

@@ -159,7 +159,7 @@ module Pkg::Util::Net
       raise(ArgumentError, "Cannot sync path '#{origin}' because both origin_host and target_host are nil. Perhaps you need to set TEAM=release ?") unless
         options[:origin_host] || options[:target_host]
 
-      cmd = %W(
+      cmd = %W[
         #{options[:bin]}
         --recursive
         --hard-links
@@ -169,7 +169,7 @@ module Pkg::Util::Net
         --no-perms
         --no-owner
         --no-group
-      ) + [*options[:extra_flags]]
+      ] + [*options[:extra_flags]]
 
       cmd << '--dry-run' if options[:dryrun]
       cmd << Pkg::Util.pseudo_uri(path: origin, host: options[:origin_host])

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