class Pkg::ManageArtifactory

The Artifactory class This class provides automation to access the artifactory repos maintained by the Release Engineering team at Puppet. It has the ability to both push artifacts to the repos, and to retrieve them back from the repos.

Constants

ARTIFACTORY_CLEANUP_SKIP_PROPERTY

The Artifactory property that the artifactCleanup user plugin {github.com/jfrog/artifactory-user-plugins/tree/master/cleanup/artifactCleanup} uses to tell it to not clean a particular artifact

DEFAULT_REPO_BASE
DEFAULT_REPO_TYPE

Public Class Methods

new(project, project_version, opts = {}) click to toggle source

@param project [String] The name of the project this package is for @param project_version [String] The version of the project we want the

package for. This can be one of three things:
  1) the final tag of the project the packages  were built from
  2) the long git sha the project the packages were built from
  3) the EZBake generated development sha where the packages live

@option :artifactory_uri [String] the uri for the artifactory server.

This currently defaults to 'https://artifactory.delivery.puppetlabs.net/artifactory'

@option :repo_base [String] The base of all repos, set for consistency.

This currently defaults to 'development'
# File lib/packaging/artifactory.rb, line 33
def initialize(project, project_version, opts = {})
  @artifactory_uri = opts[:artifactory_uri] || 'https://artifactory.delivery.puppetlabs.net/artifactory'
  @repo_base = opts[:repo_base] || DEFAULT_REPO_BASE

  @project = project
  @project_version = project_version

  Artifactory.endpoint = @artifactory_uri
end

Public Instance Methods

all_package_names(platform_data, platform_tag) click to toggle source

@param platform_data [Hash] The hash of the platform data that needs to be

parsed

@param platform_tag [String] The tag that the data we want belongs to @return [Array] An array containing all packages for the given project,

project_version, and platform_tag
# File lib/packaging/artifactory.rb, line 264
    def all_package_names(platform_data, platform_tag)
      packages = [platform_data[platform_tag][:artifact]]
      packages << platform_data[platform_tag][:additional_artifacts]
      packages.flatten!
      packages.reject! { |package| package.nil? || package.empty? }
      packages.map { |package| File.basename(package) }
    rescue
      fail_message = <<-DOC
  Package name could not be found from loaded yaml data. Either this package
  does not exist, or '#{platform_tag}' is not present in this dataset.

  The following are available platform tags for '#{@project}' '#{@project_version}':
    #{platform_data.keys.sort}
      DOC
      raise fail_message
    end
copy_artifact(artifact, target_repo, target_path, target_debian_component = nil) click to toggle source

Copy an artifact to a target repo/path

@param artifact [Artifactory::Resource::Artifact] The artifact to be copied @param target_repo [String] The repository to copy the artifact to @param target_path [String] The path in the target repository to copy the artifact to @param target_debian_component [String] `deb.component` property to set on the copied artifact

defaults to `Pkg::Paths.debian_component_from_path(target_path)`
# File lib/packaging/artifactory.rb, line 551
def copy_artifact(artifact, target_repo, target_path, target_debian_component = nil)
  filename = File.basename(artifact.download_uri)
  artifactory_target_path = "#{target_repo}/#{target_path}"
  puts "Copying #{artifact.download_uri} to #{artifactory_target_path}"
  begin
    artifact.copy(artifactory_target_path)
  rescue Artifactory::Error::HTTPError
    STDERR.puts "Could not copy #{artifactory_target_path}. Source and destination are the same. Skipping..."
  end

  if File.extname(filename) == '.deb'
    target_debian_component ||= Pkg::Paths.debian_component_from_path(target_path)
    copied_artifact_search = search_with_path(filename, target_repo, target_path)
    fail "Error: what the hell, could not find just-copied package #{filename} under #{target_repo}/#{target_path}" if copied_artifact_search.empty?
    copied_artifact = copied_artifact_search.first
    properties = { 'deb.component' => target_debian_component }
    copied_artifact.properties(properties)
  end
 end
copy_final_pe_tarballs(pe_version, repo, remote_path, target_path) click to toggle source

When we ship a new PE release we copy final tarballs to archives/releases @param pe_version [String] pe final tag @param repo [String] repo the tarballs live @param remote_path [String] path to tarballs in the repo @param target_path [String] path copy tarballs to, assumes same repo

# File lib/packaging/artifactory.rb, line 530
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, exact_match: false)
  final_tarballs.each do |artifact|
    next unless artifact.download_uri.include? remote_path
    next if artifact.download_uri.include? "-rc"
    filename = File.basename(artifact.download_uri)
    # Artifactory does NOT like when you use `File.join`, so let's concatenate!
    full_target_path = "#{repo}/#{target_path}/#{filename}"
    puts "INFO: Copying #{filename} to #{full_target_path} . . ."
    artifact.copy(full_target_path)
  end
end
deb_list_contents(platform_tag) click to toggle source

@param platform_tag [String] The platform to generate the list contents

for

@return [String] The contents of the debian list file to enable the

debian artifactory repos for the specified project and version
# File lib/packaging/artifactory.rb, line 107
def deb_list_contents(platform_tag)
  data = platform_specific_data(platform_tag)
  if data[:package_format] == 'deb'
    return "deb #{@artifactory_uri}/#{data[:repo_name]} #{data[:codename]} #{data[:repo_subdirectories]}"
  end
  raise "The platform '#{platform_tag}' is not an apt-based system."
end
deploy_package(package) click to toggle source

@param package [String] The full relative path to the package to be

shipped, relative from the current working directory
# File lib/packaging/artifactory.rb, line 213
def deploy_package(package)
  platform_tag = Pkg::Paths.tag_from_artifact_path(package) || DEFAULT_REPO_TYPE
  data = platform_specific_data(platform_tag)

  check_authorization
  artifact = Artifactory::Resource::Artifact.new(local_path: package)
  artifact_md5 = Digest::MD5.file(package).hexdigest
  headers = { "X-Checksum-Md5" => artifact_md5 }
  artifact.upload(
    data[:repo_name],
    File.join(data[:repo_subdirectories], File.basename(package)),
    deploy_properties(platform_tag, File.basename(package)),
    headers
  )
end
deploy_properties(platform_tag, file_name) click to toggle source

@param platform_tag [String] The platform tag to generate deploy

properties for

@return [String] Any required extra bits that we need for the curl

command used to deploy packages to artifactory

These are a few examples from chef/artifactory-client. These could
potentially be very powerful, but we should decide how to use them.
  status: 'DEV',
  rating: 5,
  branch: 'master'

Currently we are including everything that would be included in the yaml
file that is generated at package build time.
# File lib/packaging/artifactory.rb, line 172
def deploy_properties(platform_tag, file_name)
  data = platform_specific_data(platform_tag)

  # TODO This method should be returning the entire contents of the yaml
  # file in hash form to include as metadata for these artifacts. In this
  # current iteration, the hash isn't formatted properly and the attempt to
  # deploy to Artifactory bails out. I'm leaving this in so that we at least
  # have multiple places to remind us that it needs to happen.
  #properties_hash = Pkg::Config.config_to_hash
  properties_hash = {}
  if data[:package_format] == 'deb'
    architecture = data[:architecture]
    # set arch correctly for noarch packages
    if file_name =~ /_all\.deb$/
      architecture = 'all'
    end
    properties_hash.merge!({
      'deb.distribution' => data[:codename],
      'deb.component' => data[:repo_subdirectories],
      'deb.architecture' => architecture,
    })
  end
  properties_hash
end
download_artifact(artifact_name, repo, path, target: '.', filename: nil) click to toggle source

Download an artifact based on name, repo, and path to artifact @param artifact_name [String] name of artifact to download @param repo [String] repo the artifact lives @param path [String] path to artifact in the repo @param target [String] directory to download artifact to. Defaults to '.' @param filename [String] Filename to save artifact as. Defaults to artifact_name

# File lib/packaging/artifactory.rb, line 487
def download_artifact(artifact_name, repo, path, target: '.', filename: nil)
  filename ||= artifact_name
  artifacts = search_with_path(artifact_name, repo, path)
  return nil if artifacts.empty?
  # Only download the first of the artifacts since we're saving them to
  # the same location anyways
  artifacts.first.download(target, filename: filename)
end
download_beta_pe_tarballs(beta_tag, repo, remote_path, local_path) click to toggle source

Download beta pe tarballs to local path based on tag, repo, and path on artifactory @param beta_tag [String] rc tag of beta release ex. 2019.2.0-rc10 @param repo [String] repo the tarballs live @param remote_path [String] path to tarballs in the repo @param local_path [String] local path to download tarballs to

# File lib/packaging/artifactory.rb, line 516
def download_beta_pe_tarballs(beta_tag, repo, remote_path, local_path)
  check_authorization
  pattern = "#{remote_path}/*-#{beta_tag}-*"
  artifacts = Artifactory::Resource::Artifact.pattern_search(repo: repo, pattern: pattern)
  artifacts.each do |artifact|
    artifact.download(local_path)
  end
end
download_final_pe_tarballs(pe_version, repo, remote_path, local_path) click to toggle source

Download final pe tarballs to local path based on name, repo, and path on artifactory @param pe_version [String] pe final tag @param repo [String] repo the tarballs live @param remote_path [String] path to tarballs in the repo @param local_path [String] local path to download tarballs to

# File lib/packaging/artifactory.rb, line 501
def download_final_pe_tarballs(pe_version, repo, remote_path, local_path)
  check_authorization
  artifacts = Artifactory::Resource::Artifact.search(name: pe_version, repos: repo, exact_match: false)
  artifacts.each do |artifact|
    next unless artifact.download_uri.include? remote_path
    next if artifact.download_uri.include? "-rc"
    artifact.download(local_path)
  end
end
download_packages(staging_directory, manifest, remote_path = '') click to toggle source

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 remote_path [String] Optional partial path on the remote host containing packages

Used to specify which subdirectories packages will be downloaded from.
# File lib/packaging/artifactory.rb, line 350
def download_packages(staging_directory, manifest, remote_path = '')
  check_authorization
  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
      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
      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
        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
    end
  end
end
location_for(platform_tag) click to toggle source

@param platform_tag [String] The platform tag string for the repo we need

information on. If generic information is needed, pass in `generic`

@return [Array] An array containing three items, first being the main repo

name for the platform_tag, the second being the subdirectories of the
repo leading to the artifact we want to install, and the third being the
alternate subdirectories for a given repo. This last option is only
currently used for debian platforms, where the path to the repo
specified in the list file is different than the full path to the repo.
# File lib/packaging/artifactory.rb, line 51
def location_for(platform_tag)
  toplevel_repo = DEFAULT_REPO_TYPE
  repo_subdirectories = File.join(@repo_base, @project, @project_version)

  unless platform_tag == DEFAULT_REPO_TYPE
    format = Pkg::Platforms.package_format_for_tag(platform_tag)
    platform, version, architecture = Pkg::Platforms.parse_platform_tag(platform_tag)
  end

  case format
  when 'rpm'
    toplevel_repo = 'rpm'
    repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}-#{architecture}")
  when 'deb'
    toplevel_repo = 'debian__local'
    repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}")
  when 'swix', 'dmg', 'svr4', 'ips'
    repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}-#{architecture}")
  when 'msi'
    repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{architecture}")
  end

  [toplevel_repo, repo_subdirectories]
end
package_exists_on_artifactory?(package) click to toggle source

Basic method to check if a package exists on artifactory @param package [String] The full relative path to the package to be

checked, relative from the current working directory

Return true if package already exists on artifactory

# File lib/packaging/artifactory.rb, line 201
def package_exists_on_artifactory?(package)
  check_authorization
  artifact = Artifactory::Resource::Artifact.search(name: File.basename(package), :artifactory_uri => @artifactory_uri)
  if artifact.empty?
    return false
  else
    return true
  end
end
package_name(platform_data, platform_tag) click to toggle source

@param platform_data [Hash] The hash of the platform data that needs to be

parsed

@param platform_tag [String] The tag that the data we want belongs to @return [String] The name of the package for the given project,

project_version, and platform_tag
# File lib/packaging/artifactory.rb, line 246
    def package_name(platform_data, platform_tag)
      return File.basename(platform_data[platform_tag][:artifact])
    rescue
      fail_message = <<-DOC
  Package name could not be found from loaded yaml data. Either this package
  does not exist, or '#{platform_tag}' is not present in this dataset.

  The following are available platform tags for '#{@project}' '#{@project_version}':
    #{platform_data.keys.sort}
      DOC
      raise fail_message
    end
platform_specific_data(platform_tag) click to toggle source

@param platform_tag [String] The platform tag specific to the information

we need. If only the generic information is needed, pass in `generic`

@return [Hash] Returns a hash of data specific to this platform tag

# File lib/packaging/artifactory.rb, line 79
def platform_specific_data(platform_tag)
  unless platform_tag == DEFAULT_REPO_TYPE
    platform, version, architecture = Pkg::Platforms.parse_platform_tag(platform_tag)
    package_format = Pkg::Platforms.package_format_for_tag(platform_tag)
    if package_format == 'deb'
      codename = Pkg::Platforms.codename_for_platform_version(platform, version)
    end
  end

  repo_name, repo_subdirectories = location_for(platform_tag)
  full_artifactory_path = File.join(repo_name, repo_subdirectories)

  {
    platform: platform,
    platform_version: version,
    architecture: architecture,
    codename: codename,
    package_format: package_format,
    repo_name: repo_name,
    repo_subdirectories: repo_subdirectories,
    full_artifactory_path: full_artifactory_path
  }
end
populate_pe_repos(manifest, target_path) click to toggle source

When we cut a new PE branch, we need to copy the pe components into <pe_version>/{repos,feature,release}/<platform> @param manifest [File] JSON file containing information about what packages to download and the corresponding md5sums @param target_path [String] path on artifactory to copy components to, e.g. <pe_version>/release

# File lib/packaging/artifactory.rb, line 574
def populate_pe_repos(manifest, target_path)
  check_authorization
  manifest.each do |dist, packages|
    puts "Copying #{dist} packages..."
    packages.each do |name, info|
      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?
        raise "Error: what the hell, could not find package #{filename} with md5sum #{info["md5"]}"
      end
      copy_artifact(artifact, artifact.repo, "#{target_path}/#{dist}/#{filename}")
    end
  end
end
prevent_artifact_cleanup(repo, directory, pe_build_version) click to toggle source

Start by clearing the ARTIFACTORY_CLEANUP_SKIP_PROPERTY on all artifacts in a single repo/directory location. This allows all artifacts in the directory to be cleaned. Once cleared, set ARTIFACTORY_CLEANUP_SKIP_PROPERTY on those matching pe_build_version, presumably the latest. This prevents those artifacts from being deleted.

@param repo [String] Artifactory repository that contains the specified directory @param directory [String] Artifactory directory in repo containing the artifacts from which to

set the 'cleanup.skip' property setting to false

@param pe_build_version [String] Set 'cleanup.skip' property on artifacts that

contain this string in their file inside the directory.
# File lib/packaging/artifactory.rb, line 438
def prevent_artifact_cleanup(repo, directory, pe_build_version)
  # Clean up any trailing slashes on directory, just in case
  directory.sub!(/(\/)+$/, '')

  all_artifacts_pattern = "#{directory}/*"
  latest_artifacts_pattern = "#{directory}/*#{pe_build_version}*"

  all_artifacts = Artifactory::Resource::Artifact.pattern_search(
    repo: repo,
    pattern: all_artifacts_pattern
  )
  latest_artifacts = Artifactory::Resource::Artifact.pattern_search(
    repo: repo,
    pattern: latest_artifacts_pattern
  )

  # Clear cleanup.skip on all artifacts in directory
  puts "Clearing #{ARTIFACTORY_CLEANUP_SKIP_PROPERTY} in #{repo}/#{all_artifacts_pattern}"
  all_artifacts.each do |artifact|
    artifact.properties(ARTIFACTORY_CLEANUP_SKIP_PROPERTY => false)
  end

  # Set cleanup.skip on all artifacts in directory matching *pe_build_version*
  puts "Setting #{ARTIFACTORY_CLEANUP_SKIP_PROPERTY} in #{repo}/#{latest_artifacts_pattern}"
  latest_artifacts.each do |artifact|
    artifact.properties(ARTIFACTORY_CLEANUP_SKIP_PROPERTY => true)
  end
end
promote_package(pkg, ref, platform_tag, repository, debian_component = nil) click to toggle source

Promotes a build based on build SHA or tag (or SNAPSHOT version, for ezbake) Depending on if it's an RPM or Deb package promote accordingly 'promote' by copying the package(s) to the enterprise directory on artifactory

@param pkg [String] the package name ex. puppet-agent @param ref [String] tag or SHA of package(s) to be promoted @param platform_tag [String] the platform tag of the artifact

ex. el-7-x86_64, ubuntu-18.04-amd64

@param repository [String] the repository to promote

the artifact to. Will prepend 'rpm_' or 'debian_' to the repositories
depending on package type

@param debian_component [String] the debian component to promote packages

into. Optional.
# File lib/packaging/artifactory.rb, line 294
def promote_package(pkg, ref, platform_tag, repository, debian_component = nil)
  # load package metadata
  yaml_content = retrieve_yaml_data(pkg, ref)
  yaml_data = YAML::load(yaml_content)

  # get the artifact name
  artifact_names = all_package_names(yaml_data[:platform_data], platform_tag)
  artifact_names.each do |artifact_name|
    artifact_search_results = Artifactory::Resource::Artifact.search(
      name: artifact_name, :artifactory_uri => @artifactory_uri)

    if artifact_search_results.empty?
      raise "Error: could not find PKG=#{pkg} at REF=#{ref} for #{platform_tag}"
    end
    artifact_to_promote = artifact_search_results[0]

    # This makes an assumption that we're using some consistent repo names
    # but need to either prepend 'rpm_' or 'debian_' based on package type
    case File.extname(artifact_name)
    when '.rpm'
      promotion_path = "rpm_#{repository}/#{platform_tag}/#{artifact_name}"
    when '.deb'
      promotion_path = "debian_#{repository}/#{platform_tag}/#{artifact_name}"
      properties = { 'deb.component' => debian_component } unless debian_component.nil?
    else
      raise "Error: Unknown promotion repository for #{artifact_name}! Only .rpm and .deb files are supported!"
    end

    begin
      source_path = artifact_to_promote.download_uri.sub(@artifactory_uri, '')
      puts "promoting #{artifact_name} from #{source_path} to #{promotion_path}"
      artifact_to_promote.copy(promotion_path)
      unless properties.nil?
        artifacts = Artifactory::Resource::Artifact.search(name: artifact_name, :artifactory_uri => @artifactory_uri)
        promoted_artifact = artifacts.select { |artifact| artifact.download_uri =~ %r{#{promotion_path}} }.first
        promoted_artifact.properties(properties)
      end
    rescue Artifactory::Error::HTTPError => e
      if e.message =~ /(destination and source are the same|user doesn't have permissions to override)/i
        puts "Skipping promotion of #{artifact_name}; it has already been promoted"
      else
        puts "#{e.message}"
        raise e
      end
    rescue => e
      puts "Something went wrong promoting #{artifact_name}!"
      raise e
    end
  end
end
purge_copied_pe_tarballs(tarball_path, pe_repo) click to toggle source

Remove shipped PE tarballs from artifactory Used when compose fails, we only want the tarball shipped to artifactory if all platforms succeed Identify which packages were created and shipped based on md5sum and remove them @param tarball_path [String] the local path to the tarballs that were shipped @param pe_repo [String] the artifactory repo the tarballs were shipped to

# File lib/packaging/artifactory.rb, line 629
def purge_copied_pe_tarballs(tarball_path, pe_repo)
  check_authorization
  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, name: pe_tarball)
    next if artifacts_to_delete.nil?
    begin
      artifacts_to_delete.each do |artifact|
        puts "Removing #{pe_tarball} from #{pe_repo}... "
        artifact.delete
      end
    rescue Artifactory::Error::HTTPError
      STDERR.puts "Error: cannot remove #{pe_tarball}, do you have the right permissions?"
    end
  end
end
remove_promoted_packages(manifest, remote_path, package, repos) click to toggle source

Remove promoted artifacts if promotion is reverted, use information provided in manifest @param manifest [File] JSON file containing information about what packages to download and the corresponding md5sums @param remote_path [String] path on artifactory to promoted packages ex. 2019.1/repos/ @param package [String] package name ex. puppet-agent @param repos [Array] the repos the promoted artifacts live

# File lib/packaging/artifactory.rb, line 608
def remove_promoted_packages(manifest, remote_path, package, repos)
  check_authorization
  manifest.each do |dist, packages|
    packages.each do |package_name, info|
      next unless package_name == package
      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}"
        artifact.delete
      end
    end
  end
end
retrieve_yaml_data(pkg, ref) click to toggle source

@param pkg [String] The package to download YAML for

i.e. 'puppet-agent' or 'puppetdb'

@param ref [String] The git ref (sha or tag) we want the YAML for

@return [String] The contents of the YAML file

# File lib/packaging/artifactory.rb, line 234
def retrieve_yaml_data(pkg, ref)
  yaml_url = "#{@artifactory_uri}/#{DEFAULT_REPO_TYPE}/#{DEFAULT_REPO_BASE}/#{pkg}/#{ref}/#{ref}.yaml"
  open(yaml_url) { |f| f.read }
rescue
  raise "Failed to load YAML data for #{pkg} at #{ref} from #{yaml_url}!"
end
rpm_repo_contents(platform_tag) click to toggle source

@param platform_tag [String] The platform to generate the repo file

contents for

@return [String] The contents of the rpm repo file to enable the rpm

artifactory repo for the specified project and version
# File lib/packaging/artifactory.rb, line 119
    def rpm_repo_contents(platform_tag)
      data = platform_specific_data(platform_tag)
      if data[:package_format] == 'rpm'
        return <<-DOC
  [Artifactory #{@project} #{@project_version} for #{platform_tag}]
  name=Artifactory Repository for #{@project} #{@project_version} for #{platform_tag}
  baseurl=#{@artifactory_uri}/#{data[:repo_name]}/#{data[:repo_subdirectories]}
  enabled=1
  gpgcheck=0
  #Optional - if you have GPG signing keys installed, use the below flags to verify the repository metadata signature:
  #gpgkey=#{@artifactory_uri}/#{data[:repo_name]}/#{data[:repo_subdirectories]}/repomd.xml.key
  #repo_gpgcheck=1
        DOC
      end
      raise "The platform '#{platform_tag}' is not a yum-based system"
    end
search_with_path(artifact_id, repo, path) click to toggle source

Search for artifacts matching `artifact_name` in `repo` with path matching `path` @param artifact_name [String] name of artifact to download @param repo [String] repo the artifact lives @param path [String] path to artifact in the repo

@return [Array<Artifactory::Resource::Artifact>] A list of artifacts that

match the query
# File lib/packaging/artifactory.rb, line 475
def search_with_path(artifact_id, repo, path)
  check_authorization
  artifacts = Artifactory::Resource::Artifact.search(name: artifact_id, repos: repo)
  artifacts.select { |artifact| artifact.download_uri.include? path }
end
ship_pe_tarballs(local_tarball_directory, target_repo, ship_paths) click to toggle source

Ship PE tarballs to specified artifactory repo and paths @param local_tarball_directory [String] the local directory containing the tarballs @param target_repo [String] the artifactory repo to ship the tarballs to @param ship_paths [Array] the artifactory path(s) to ship the tarballs to within

the target_repo
# File lib/packaging/artifactory.rb, line 388
def ship_pe_tarballs(local_tarball_directory, target_repo, ship_paths)
  check_authorization
  ship_paths.each do |path|
    Dir.foreach(local_tarball_directory) do |pe_tarball|
      next if pe_tarball == '.' || pe_tarball == ".."
      begin
        puts "Uploading #{pe_tarball} to #{target_repo}/#{path}#{pe_tarball}"
        artifact = Artifactory::Resource::Artifact.new(
          local_path: "#{local_tarball_directory}/#{pe_tarball}")
        artifact.upload(target_repo, "#{path}#{pe_tarball}")
      rescue Errno::EPIPE
        STDERR.puts "Warning: Could not upload #{pe_tarball} to #{target_repo}/#{path}. Skipping."
        next
      end
    end
  end
end
teardown_repo(repos, pattern) click to toggle source

Remove all artifacts in repo based on pattern, used when we purge all artifacts in release/ after PE release @param repos [Array] repos that we want to search for artifacts in @param pattern [String] pattern for artifacts that should be deleted ex. `2019.1/release//`

# File lib/packaging/artifactory.rb, line 592
def teardown_repo(repos, pattern)
  check_authorization
  repos.each do |repo|
    artifacts = Artifactory::Resource::Artifact.pattern_search(repo: repo, pattern: pattern)
    artifacts.each do |artifact|
      puts "Deleting #{artifact.download_uri}"
      artifact.delete
    end
  end
end
upload_file(local_path, target_repo, target_path, properties = {}, headers = {}) click to toggle source

Upload file to Artifactory @param local_path [String] local path to file to upload @param target_repo [String] repo on artifactory to upload to @param target_path [String] path within target_repo to upload to @param properties [Hash] Optional property names and values to assign the uploaded file

For example, this would set both the 'cleanup.skip' and 'deb.component' properties:
\{ "cleanup.skip" => true, "deb.component" => 'bionic' \}

@param headers [Hash] Optional upload headers, most likely checksums, for the upload request

"X-Checksum-Md5" and "X-Checksum-Sha1" are typical
# File lib/packaging/artifactory.rb, line 415
def upload_file(local_path, target_repo, target_path, properties = {}, headers = {})
  fail "Error: Couldn't find file at #{local_path}." unless File.exist? local_path
  check_authorization
  artifact = Artifactory::Resource::Artifact.new(local_path: local_path)
  full_upload_path = File.join(target_path, File.basename(local_path))
  begin
    puts "Uploading #{local_path} to #{target_repo}/#{full_upload_path} . . ."
    artifact.upload(target_repo, full_upload_path, properties, headers)
  rescue Artifactory::Error::HTTPError => e
    fail "Error: Upload failed. Ensure path #{target_path} exists in the #{target_repo} repository."
  end
end

Private Instance Methods

check_authorization() click to toggle source

Verify the correct environment variables are set in order to process authorization to access the artifactory repos

# File lib/packaging/artifactory.rb, line 138
    def check_authorization
      unless (ENV['ARTIFACTORY_USERNAME'] && ENV['ARTIFACTORY_PASSWORD']) || ENV['ARTIFACTORY_API_KEY']
        raise <<-DOC
  Unable to determine credentials for Artifactory. Please set one of the
  following environment variables:

  For basic authentication, please set:
  ARTIFACTORY_USERNAME
  ARTIFACTORY_PASSWORD

  If you would like to use the API key, ensure ARTIFACTORY_USERNAME and
  ARTIFACTORY_PASSWORD are not set, as these take precedence. Instead, please
  set:
  ARTIFACTORY_API_KEY

  You can also set the path to a pem file with your custom certificates with:
  ARTIFACTORY_SSL_PEM_FILE
        DOC
      end
    end