packaging 0.99.61 → 0.99.66

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad27ca2f1724bfea741b3e69538fdb238acc76ea1662a6e40a44f433eb66e457
-  data.tar.gz: 87aad9c6e3f8e13abcaf437fbe1fceb113ee596073d04a3e997f4d12c38d6edc
+  metadata.gz: 47aedaa86f3b67d8c5c0dac793bdc7ba76098d59a69a371d686ad040a82bcad7
+  data.tar.gz: 46903f549c65511da61bc15448809e2442d8569b9cc7c318b3a44c9d1389a4a8
 SHA512:
-  metadata.gz: d6af0709a72179d3489e2ea6c3940be0f69d715e34c81cd19e5378badd136d7ec6db068d18d610cbb8448ba4053aa04f5fdda4708e273d27b38ffb786cd55da2
-  data.tar.gz: 22f8aab7c11a57fa87f836047b5ee441a1cfbaf04df579b00b3cb15d8eeec2a7c32500ec56d9c2edf86e2c4e4b267076cc345e2bd8731962a904046b2d4219fd
+  metadata.gz: 2a4f6a1f1135c242cb3561b609943a44715f9bbf45653f76548c2682819dbf14c1a1f1909380a70b7c5b054eebbd871c0572760c8d76e104fae19b9fedb330d5
+  data.tar.gz: 69bb9b00a3e3711911fc98a4b68d175f9e79553e4c100db4a02ab4e57be3a6ed71c00b0014b19ff5ef5c30c22796e22db73efff32f9775ddf05b9204c12c6885

data/lib/packaging/artifactory.rb

@@ -2,67 +2,7 @@ require 'artifactory'
 require 'uri'
 require 'open-uri'
 require 'digest'
-
-#
-# [eric.griswold] This is unfortunate. The 'pattern_search' class method really does belong in
-# the Artifactory gem. However, because of some of Chef's social policies,
-# I am unwilling to contribute this code there. If that changes, I'll submit a PR. Until
-# then, it'll live here.
-#
-module Artifactory
-  class Resource::Artifact
-    #
-    # Search for an artifact in a repo using an Ant-like pattern.
-    # Unlike many Artifactory searches, this one is restricted to a single
-    # repository.
-    #
-    # @example Search in a repository named 'foo_local' for an artifact in a directory containing
-    #   the word "recent", named "artifact[0-9].txt"
-    #   Artifact.pattern_search(pattern: '*recent*/artifact[0-9].txt',
-    #                           repo: 'foo_local')
-    #
-    # @param [Hash] options
-    #   A hash of options, as follows:
-    #
-    # @option options [Artifactory::Client] :client
-    #   the client object to make the request with
-    # @option options [String] :pattern
-    #   the Ant-like pattern to use for finding artifacts within the repos. Note that the
-    #   Ant pattern '**' is barred in this case by JFrog.
-    # @option options [String] :repo
-    #   the repo to search
-    #
-    # @return [Array<Resource::Artifact>]
-    #   a list of artifacts that match the query
-    #
-    def self.pattern_search(options = {})
-      client = extract_client!(options)
-      params = Util.slice(options, :pattern, :repo)
-      pattern_search_parameter = { :pattern => "#{params[:repo]}:#{params[:pattern]}" }
-      response = client.get('/api/search/pattern', pattern_search_parameter)
-      return [] if response['files'].nil? || response['files'].empty?
-
-      # A typical response:
-      # {
-      #  "repoUri"=>"https:<artifactory endpoint>/<repo>",
-      #  "sourcePattern"=>"<repo>:<provided search pattern>",
-      #  "files"=>[<filename that matched pattern>, ...]
-      # }
-      #
-      # Inserting '/api/storage' before the repo makes the 'from_url' call work correctly.
-      #
-      repo_uri = response['repoUri']
-      unless repo_uri.include?('/api/storage/')
-        # rubocop:disable Style/PercentLiteralDelimiters
-        repo_uri.sub!(%r(/#{params[:repo]}$), "/api/storage/#{params[:repo]}")
-      end
-      response['files'].map do |file_path|
-        from_url("#{repo_uri}/#{file_path}", client: client)
-      end
-    end
-  end
-end
-
+require 'packaging/artifactory/extensions'
 
 module Pkg
 
@@ -111,7 +51,6 @@ module Pkg
     def location_for(platform_tag)
       toplevel_repo = DEFAULT_REPO_TYPE
       repo_subdirectories = File.join(@repo_base, @project, @project_version)
-      alternate_subdirectories = repo_subdirectories
 
       unless platform_tag == DEFAULT_REPO_TYPE
         format = Pkg::Platforms.package_format_for_tag(platform_tag)
@@ -122,20 +61,16 @@ module Pkg
       when 'rpm'
         toplevel_repo = 'rpm'
         repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}-#{architecture}")
-        alternate_subdirectories = repo_subdirectories
       when 'deb'
         toplevel_repo = 'debian__local'
         repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}")
-        alternate_subdirectories = File.join('pool', repo_subdirectories)
       when 'swix', 'dmg', 'svr4', 'ips'
         repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}-#{architecture}")
-        alternate_subdirectories = repo_subdirectories
       when 'msi'
         repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{architecture}")
-        alternate_subdirectories = repo_subdirectories
       end
 
-      [toplevel_repo, repo_subdirectories, alternate_subdirectories]
+      [toplevel_repo, repo_subdirectories]
     end
 
     # @param platform_tag [String] The platform tag specific to the information
@@ -150,8 +85,8 @@ module Pkg
         end
       end
 
-      repo_name, repo_subdirectories, alternate_subdirectories = location_for(platform_tag)
-      full_artifactory_path = File.join(repo_name, alternate_subdirectories)
+      repo_name, repo_subdirectories = location_for(platform_tag)
+      full_artifactory_path = File.join(repo_name, repo_subdirectories)
 
       {
         platform: platform,
@@ -161,7 +96,6 @@ module Pkg
         package_format: package_format,
         repo_name: repo_name,
         repo_subdirectories: repo_subdirectories,
-        alternate_subdirectories: alternate_subdirectories,
         full_artifactory_path: full_artifactory_path
       }
     end
@@ -286,7 +220,7 @@ module Pkg
       headers = { "X-Checksum-Md5" => artifact_md5 }
       artifact.upload(
         data[:repo_name],
-        File.join(data[:alternate_subdirectories], File.basename(package)),
+        File.join(data[:repo_subdirectories], File.basename(package)),
         deploy_properties(platform_tag, File.basename(package)),
         headers
       )
@@ -420,21 +354,20 @@ module Pkg
       manifest.each do |dist, packages|
         puts "Grabbing the #{dist} packages from artifactory"
         packages.each do |name, info|
-          artifacts = Artifactory::Resource::Artifact.checksum_search(md5: "#{info["md5"]}", repos: ["rpm_enterprise__local", "debian_enterprise__local"])
+          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
           if artifact_to_download.nil? && !artifacts.empty?
             artifact_to_copy = artifacts.first
-            filename = info['filename'] || File.basename(artifact_to_copy.download_uri)
             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"])
+            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
           end
 
           if artifact_to_download.nil?
-            filename = info["filename"] || name
             message = "Error: what the hell, could not find package #{filename} with md5sum #{info["md5"]}"
             unless remote_path.empty?
               message += " in #{remote_path}"
@@ -442,7 +375,6 @@ module Pkg
             raise message
           else
             full_staging_path = "#{staging_directory}/#{dist}"
-            filename = info['filename'] || File.basename(artifact_to_download.download_uri)
             puts "downloading #{artifact_to_download.download_uri} to #{File.join(full_staging_path, filename)}"
             artifact_to_download.download(full_staging_path, filename: filename)
           end
@@ -599,7 +531,7 @@ module Pkg
     # @param target_path [String] path copy tarballs to, assumes same repo
     def copy_final_pe_tarballs(pe_version, repo, remote_path, target_path)
       check_authorization
-      final_tarballs = Artifactory::Resource::Artifact.search(name: pe_version, repos: repo)
+      final_tarballs = Artifactory::Resource::Artifact.search(name: pe_version, repos: repo, exact_match: false)
       final_tarballs.each do |artifact|
         next unless artifact.download_uri.include? remote_path
         next if artifact.download_uri.include? "-rc"
@@ -646,12 +578,11 @@ module Pkg
       manifest.each do |dist, packages|
         puts "Copying #{dist} packages..."
         packages.each do |name, info|
-          artifact = Artifactory::Resource::Artifact.checksum_search(md5: "#{info["md5"]}", repos: ["rpm_enterprise__local", "debian_enterprise__local"]).first
+          filename = info["filename"]
+          artifact = Artifactory::Resource::Artifact.checksum_search(md5: "#{info["md5"]}", repos: ["rpm_enterprise__local", "debian_enterprise__local"], name: filename).first
           if artifact.nil?
-            filename = info["filename"] || name
             raise "Error: what the hell, could not find package #{filename} with md5sum #{info["md5"]}"
           end
-          filename = info["filename"] || File.basename(artifact.download_uri)
           copy_artifact(artifact, artifact.repo, "#{target_path}/#{dist}/#{filename}")
         end
       end
@@ -681,7 +612,8 @@ module Pkg
       manifest.each do |dist, packages|
         packages.each do |package_name, info|
           next unless package_name == package
-          artifacts = Artifactory::Resource::Artifact.checksum_search(md5: "#{info["md5"]}", repos: repos)
+          filename = info["filename"]
+          artifacts = Artifactory::Resource::Artifact.checksum_search(md5: "#{info["md5"]}", repos: repos, name: filename)
           artifacts.each do |artifact|
             next unless artifact.download_uri.include? remote_path
             puts "Removing reverted package #{artifact.download_uri}"
@@ -701,7 +633,7 @@ module Pkg
       Dir.foreach("#{tarball_path}/") do |pe_tarball|
         next if pe_tarball == '.' || pe_tarball == ".."
         md5 = Digest::MD5.file("#{tarball_path}/#{pe_tarball}").hexdigest
-        artifacts_to_delete = Artifactory::Resource::Artifact.checksum_search(md5: md5, repos: pe_repo)
+        artifacts_to_delete = Artifactory::Resource::Artifact.checksum_search(md5: md5, repos: pe_repo, name: pe_tarball)
         next if artifacts_to_delete.nil?
         begin
           artifacts_to_delete.each do |artifact|

data/lib/packaging/artifactory/extensions.rb

@@ -0,0 +1,94 @@
+require 'artifactory'
+
+module ArtifactoryExtensions
+  module ClassMethods
+    #
+    # Search for an artifact in a repo using an Ant-like pattern.
+    # Unlike many Artifactory searches, this one is restricted to a single
+    # repository.
+    #
+    # @example Search in a repository named 'foo_local' for an artifact in a directory containing
+    #   the word "recent", named "artifact[0-9].txt"
+    #   Artifact.pattern_search(pattern: '*recent*/artifact[0-9].txt',
+    #                           repo: 'foo_local')
+    #
+    # @param [Hash] options
+    #   A hash of options, as follows:
+    #
+    # @option options [Artifactory::Client] :client
+    #   the client object to make the request with
+    # @option options [String] :pattern
+    #   the Ant-like pattern to use for finding artifacts within the repos. Note that the
+    #   Ant pattern '**' is barred in this case by JFrog.
+    # @option options [String] :repo
+    #   the repo to search
+    #
+    # @return [Array<Resource::Artifact>]
+    #   a list of artifacts that match the query
+    #
+    def pattern_search(options = {})
+      client = extract_client!(options)
+      params = Artifactory::Util.slice(options, :pattern, :repo)
+      pattern_search_parameter = { :pattern => "#{params[:repo]}:#{params[:pattern]}" }
+      response = client.get('/api/search/pattern', pattern_search_parameter)
+      return [] if response['files'].nil? || response['files'].empty?
+
+      # A typical response:
+      # {
+      #  "repoUri"=>"https:<artifactory endpoint>/<repo>",
+      #  "sourcePattern"=>"<repo>:<provided search pattern>",
+      #  "files"=>[<filename that matched pattern>, ...]
+      # }
+      #
+      # Inserting '/api/storage' before the repo makes the 'from_url' call work correctly.
+      #
+      repo_uri = response['repoUri']
+      unless repo_uri.include?('/api/storage/')
+        # rubocop:disable Style/PercentLiteralDelimiters
+        repo_uri.sub!(%r(/#{params[:repo]}$), "/api/storage/#{params[:repo]}")
+      end
+      response['files'].map do |file_path|
+        from_url("#{repo_uri}/#{file_path}", client: client)
+      end
+    end
+
+    # This adds the `exact_match` option to artifactory search, and defaults it
+    # to true. With `exact_match` set to `true` the artifact will only be
+    # returned if the name in the download uri matches the name we're trying to
+    # download
+    def search(options = {})
+      exact_match = options[:exact_match].nil? ? true : options[:exact_match]
+      artifacts = super
+
+      if exact_match
+        artifacts.select! { |artifact| File.basename(artifact.download_uri) == options[:name] }
+      end
+      artifacts
+    end
+
+    # This adds the `name` option to artifactory checksum search. It defaults to
+    # unset. If set, the artifact is only returned if the download uri matches
+    # the passed name
+    def checksum_search(options = {})
+      artifacts = super
+      if options[:name]
+        artifacts.select! { |artifact| File.basename(artifact.download_uri) == options[:name] }
+      end
+      artifacts
+    end
+  end
+
+  # needed to prepend class methods, see https://stackoverflow.com/questions/18683750/how-to-prepend-classmethods
+  def self.prepended(base)
+    class << base
+      prepend ClassMethods
+    end
+  end
+end
+
+module Artifactory
+  class Resource::Artifact
+    # use prepend instead of monkeypatching so we can call `super`
+    prepend ArtifactoryExtensions
+  end
+end

data/lib/packaging/paths.rb

@@ -70,15 +70,6 @@ module Pkg::Paths
     end
   end
 
-  # Method to determine if files should be shipped to legacy or current path
-  # structures. Any repo name matching /^puppet/ is a current repo, everything
-  # else is should be shipped to legacy paths.
-  #
-  # @param repo_name The repo name to check
-  def is_legacy_repo?(repo_name)
-    repo_name !~ /^puppet/
-  end
-
   # Method to determine the yum repo name. Maintains compatibility with legacy
   # projects, where `Pkg::Config.yum_repo_name` is set instead of
   # `Pkg::Config.repo_name`. Defaults to 'products' if nothing is set.
@@ -110,65 +101,83 @@ module Pkg::Paths
     return Pkg::Config.repo_link_target
   end
 
-  # TODO: please please please clean this up
-  # This is so terrible. I really dislike it. But in order to maintain backward
-  # compatibility, we need to maintain these path differences between PC1 and
-  # everything else. Once we stop shipping things to PC1, we can remove all the
-  # PC1 specific cases. That's likely to not happen until the current LTS
-  # (2016.4) is EOL'd. Hopefully also we do not choose to further change these
-  # path structures, as it is no bueno.
-  # --MAS 2017-08-16
-  def artifacts_base_path_and_link_path(platform_tag, path_prefix = 'artifacts', nonfinal = false)
-    platform, version, architecture = Pkg::Platforms.parse_platform_tag(platform_tag)
-    package_format = Pkg::Platforms.package_format_for_tag(platform_tag)
+  # Construct a platform-dependent symlink target path.
+  def construct_base_path(path_data)
+    package_format = path_data[:package_format]
+    prefix = path_data[:prefix]
+    is_nonfinal = path_data[:is_nonfinal]
+    platform_name = path_data[:platform_name]
+    platform_tag = path_data[:platform_tag]
 
     case package_format
+    when 'deb'
+      debian_code_name = Pkg::Platforms.get_attribute(platform_tag, :codename)
+      return File.join(prefix, debian_code_name, apt_repo_name(is_nonfinal))
+    when 'dmg'
+      return File.join(prefix, 'mac', repo_name(is_nonfinal))
+    when 'msi'
+      return File.join(prefix, platform_name, repo_name(is_nonfinal))
     when 'rpm'
-      if is_legacy_repo?(yum_repo_name(nonfinal))
-        [File.join(path_prefix, platform, version, yum_repo_name(nonfinal)), nil]
-      else
-        [File.join(path_prefix, yum_repo_name(nonfinal)), link_name(nonfinal).nil? ? nil : File.join(path_prefix, link_name(nonfinal))]
-      end
+      return File.join(prefix, yum_repo_name(is_nonfinal))
     when 'swix'
-      if is_legacy_repo?(repo_name(nonfinal))
-        [File.join(path_prefix, platform, version, repo_name(nonfinal)), nil]
-      else
-        [File.join(path_prefix, platform, repo_name(nonfinal)), link_name(nonfinal).nil? ? nil : File.join(path_prefix, platform, link_name(nonfinal))]
-      end
+      return File.join(prefix, platform_name, repo_name(is_nonfinal))
+    when 'svr4', 'ips'
+      return File.join(prefix, 'solaris', repo_name(is_nonfinal))
+    else
+      raise "Error: Unknown package format '#{package_format}'"
+    end
+  end
+
+  # Construct a platform-dependent link path
+  def construct_link_path(path_data)
+    package_format = path_data[:package_format]
+    prefix = path_data[:prefix]
+    platform_name = path_data[:platform_name]
+    platform_tag = path_data[:platform_tag]
+    link = path_data[:link]
+
+    return nil if link.nil?
+
+    case package_format
+    when 'rpm'
+      return File.join(prefix, link)
+    when 'swix'
+      return File.join(prefix, platform_name, link)
     when 'deb'
-      [File.join(path_prefix, Pkg::Platforms.get_attribute(platform_tag, :codename), apt_repo_name(nonfinal)),
-       link_name(nonfinal).nil? ? nil : File.join(path_prefix, Pkg::Platforms.get_attribute(platform_tag, :codename), link_name(nonfinal))]
+      debian_code_name = Pkg::Platforms.get_attribute(platform_tag, :codename)
+      return File.join(prefix, debian_code_name, link)
     when 'svr4', 'ips'
-      if is_legacy_repo?(repo_name(nonfinal))
-        [File.join(path_prefix, 'solaris', repo_name(nonfinal), version), nil]
-      else
-        [File.join(path_prefix, 'solaris', repo_name(nonfinal)), link_name(nonfinal).nil? ? nil : File.join(path_prefix, 'solaris', link_name(nonfinal))]
-      end
+      return File.join(prefix, 'solaris', link)
     when 'dmg'
-      if is_legacy_repo?(repo_name(nonfinal))
-        [File.join(path_prefix, 'mac', version, repo_name(nonfinal)), nil]
-      else
-        [File.join(path_prefix, 'mac', repo_name(nonfinal)), link_name(nonfinal).nil? ? nil : File.join(path_prefix, 'mac', link_name(nonfinal))]
-      end
+      return File.join(prefix, 'mac', link)
     when 'msi'
-      if is_legacy_repo?(repo_name(nonfinal))
-        [File.join(path_prefix, 'windows'), nil]
-      else
-        [File.join(path_prefix, platform, repo_name(nonfinal)), link_name(nonfinal).nil? ? nil : File.join(path_prefix, platform, link_name(nonfinal))]
-      end
+      return File.join(prefix, platform_name, link)
     else
-      raise "Not sure where to find packages with a package format of '#{package_format}'"
+      raise "Error: Unknown package format '#{package_format}'"
     end
   end
 
-  # TODO: please please please clean this up
-  # This is so terrible. I really dislike it. But in order to maintain backward
-  # compatibility, we need to maintain these path differences between PC1 and
-  # everything else. Once we stop shipping things to PC1, we can remove all the
-  # PC1 specific cases. That's likely to not happen until the current LTS
-  # (2016.4) is EOL'd. Hopefully also we do not choose to further change these
-  # path structures, as it is no bueno.
-  # --MAS 2017-08-16
+  # Given platform information, create symlink target (base_path) and link path in the
+  # form of a 2-element array
+  def artifacts_base_path_and_link_path(platform_tag, prefix = 'artifacts', is_nonfinal = false)
+    platform_name, _ = Pkg::Platforms.parse_platform_tag(platform_tag)
+    package_format = Pkg::Platforms.package_format_for_tag(platform_tag)
+
+    path_data = {
+      is_nonfinal: is_nonfinal,
+      link: link_name(is_nonfinal),
+      package_format: package_format,
+      platform_name: platform_name,
+      platform_tag: platform_tag,
+      prefix: prefix
+    }
+
+    return [
+      construct_base_path(path_data),
+      construct_link_path(path_data)
+    ]
+  end
+
   def artifacts_path(platform_tag, path_prefix = 'artifacts', nonfinal = false)
     base_path, _ = artifacts_base_path_and_link_path(platform_tag, path_prefix, nonfinal)
     platform, version, architecture = Pkg::Platforms.parse_platform_tag(platform_tag)
@@ -176,31 +185,15 @@ module Pkg::Paths
 
     case package_format
     when 'rpm'
-      if is_legacy_repo?(yum_repo_name(nonfinal))
-        File.join(base_path, architecture)
-      else
-        File.join(base_path, platform, version, architecture)
-      end
+      File.join(base_path, platform, version, architecture)
     when 'swix'
-      if is_legacy_repo?(repo_name(nonfinal))
-        File.join(base_path, architecture)
-      else
-        File.join(base_path, version, architecture)
-      end
+      File.join(base_path, version, architecture)
     when 'deb'
       base_path
     when 'svr4', 'ips'
-      if is_legacy_repo?(repo_name(nonfinal))
-        base_path
-      else
-        File.join(base_path, version)
-      end
+      File.join(base_path, version)
     when 'dmg'
-      if is_legacy_repo?(repo_name(nonfinal))
-        File.join(base_path, architecture)
-      else
-        File.join(base_path, version, architecture)
-      end
+      File.join(base_path, version, architecture)
     when 'msi'
       base_path
     else
@@ -268,16 +261,33 @@ module Pkg::Paths
     end
   end
 
-  def remote_repo_base(platform_tag, nonfinal = false)
-    package_format = Pkg::Platforms.package_format_for_tag(platform_tag)
-    case package_format
+  def remote_repo_base(platform_tag = nil, nonfinal: false, package_format: nil)
+    if platform_tag.nil? && package_format.nil?
+      raise "Pkg::Paths.remote_repo_base must have `platform_tag` or `package_format` specified."
+    end
+
+    package_format ||= Pkg::Platforms.package_format_for_tag(platform_tag)
+
+    repo_base = case package_format
     when 'rpm'
       nonfinal ? Pkg::Config.nonfinal_yum_repo_path : Pkg::Config.yum_repo_path
     when 'deb'
       nonfinal ? Pkg::Config.nonfinal_apt_repo_path : Pkg::Config.apt_repo_path
+    when 'dmg'
+      nonfinal ? Pkg::Config.nonfinal_dmg_path : Pkg::Config.dmg_path
+    when 'swix'
+      nonfinal ? Pkg::Config.nonfinal_swix_path : Pkg::Config.swix_path
+    when 'msi'
+      nonfinal ? Pkg::Config.nonfinal_msi_path : Pkg::Config.msi_path
     else
       raise "Can't determine remote repo base path for package format '#{package_format}'."
     end
+
+    # normalize the path for things shipping to the downloads server
+    if repo_base.match(/^\/opt\/downloads\/\w+$/)
+      repo_base = '/opt/downloads'
+    end
+    repo_base
   end
 
   # This is where deb packages end up after freight repo updates
@@ -285,7 +295,7 @@ module Pkg::Paths
     fail "Can't determine path for non-debian platform #{platform_tag}." unless Pkg::Platforms.package_format_for_tag(platform_tag) == 'deb'
     platform, version, _ = Pkg::Platforms.parse_platform_tag(platform_tag)
     codename = Pkg::Platforms.codename_for_platform_version(platform, version)
-    return File.join(remote_repo_base(platform_tag, nonfinal), 'pool', codename, repo_name, project[0], project)
+    return File.join(remote_repo_base(platform_tag, nonfinal: nonfinal), 'pool', codename, repo_name, project[0], project)
   end
 
   def release_package_link_path(platform_tag, nonfinal = false)
@@ -293,10 +303,10 @@ module Pkg::Paths
     package_format = Pkg::Platforms.package_format_for_tag(platform_tag)
     case package_format
     when 'rpm'
-      return File.join(remote_repo_base(platform_tag, nonfinal), "#{repo_name(nonfinal)}-release-#{platform}-#{version}.noarch.rpm")
+      return File.join(remote_repo_base(platform_tag, nonfinal: nonfinal), "#{repo_name(nonfinal)}-release-#{platform}-#{version}.noarch.rpm")
     when 'deb'
       codename = Pkg::Platforms.codename_for_platform_version(platform, version)
-      return File.join(remote_repo_base(platform_tag, nonfinal), "#{repo_name(nonfinal)}-release-#{codename}.deb")
+      return File.join(remote_repo_base(platform_tag, nonfinal: nonfinal), "#{repo_name(nonfinal)}-release-#{codename}.deb")
     else
       warn "No release packages for package format '#{package_format}', skipping . . ."
       return nil