module Pkg::Repo

Public Class Methods

argument_required?(argument_name, repo_command) click to toggle source
# File lib/packaging/repo.rb, line 132
def argument_required?(argument_name, repo_command)
  repo_command.include?("__#{argument_name.upcase}__")
end
compress_tarball_of_all_repos(all_repos_tarball_name) click to toggle source

Invoke gzip to compress the 'all' tarball located in 'pkg/<local_target>/<project>-all.tar'

# File lib/packaging/repo.rb, line 80
def compress_tarball_of_all_repos(all_repos_tarball_name)
  gzip = Pkg::Util::Tool.check_tool('gzip')

  gzip_command = "#{gzip} --fast #{all_repos_tarball_name}"
  stdout, _, _ = Pkg::Util::Execution.capture3(gzip_command)
  puts stdout
end
construct_local_target_path(project, versioning) click to toggle source

Construct a local_target based upon the versioning style

# File lib/packaging/repo.rb, line 8
def construct_local_target_path(project, versioning)
  case versioning
  when 'ref'
    return File.join(project, Pkg::Config.ref)
  when 'version'
    return File.join(project, Pkg::Util::Version.dot_version)
  else
    fail "Error: Unknown versioning argument: #{versioning}"
  end
end
create_all_repo_archives(project, versioning) click to toggle source

Generate each of the repos listed in <Config.platform_repos>. Update the 'all repos' tarball as we do each one. Compress the 'all repos' tarball when all the repos have been generated

# File lib/packaging/repo.rb, line 93
def create_all_repo_archives(project, versioning)
  platforms = Pkg::Config.platform_repos
  local_target = construct_local_target_path(project, versioning)
  all_repos_tarball_name = "#{project}-all.tar"

  platforms.each do |platform|
    archive_name = "#{project}-#{platform['name']}"
    create_signed_repo_archive(platform['repo_location'], archive_name, versioning)
    update_tarball_of_all_repos(project, platform, versioning)
  end

  Dir.chdir(File.join('pkg', local_target)) do
    compress_tarball_of_all_repos(all_repos_tarball_name)
  end
end
create_signed_repo_archive(repo_location, archive_name, versioning) click to toggle source

Put a single signed repo into a tarball stored in 'pkg/<local_target>/<archive_name>.tar.gz'

# File lib/packaging/repo.rb, line 23
def create_signed_repo_archive(repo_location, archive_name, versioning)
  tar = Pkg::Util::Tool.check_tool('tar')

  local_target = construct_local_target_path(Pkg::Config.project, versioning)

  if Pkg::Util::File.empty_dir?(File.join('pkg', local_target, repo_location))
    if ENV['FAIL_ON_MISSING_TARGET'] == "true"
      raise "Error: missing packages under #{repo_location}"
    end
    warn "Warn: Skipping #{archive_name} because #{repo_location} has no files"
    return
  end

  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}"
    stdout, _, _ = Pkg::Util::Execution.capture3(tar_command)
    return stdout
  end
end
directories_that_contain_packages(artifact_directory, pkg_ext) click to toggle source
# File lib/packaging/repo.rb, line 109
def directories_that_contain_packages(artifact_directory, pkg_ext)
  cmd = "[ -d #{artifact_directory} ] || exit 1 ; "
  cmd << "pushd #{artifact_directory} > /dev/null && "
  cmd << "find . -name '*.#{pkg_ext}' -print0 | xargs --no-run-if-empty -0 -I {} dirname {} "
  stdout, _ = Pkg::Util::Net.remote_execute(
            Pkg::Config.distribution_server,
            cmd,
            { capture_output: true }
          )
  return stdout.split
rescue => e
  fail "Error: Could not retrieve directories that contain #{pkg_ext} packages in #{Pkg::Config.distribution_server}:#{artifact_directory}"
end
populate_repo_directory(artifact_parent_directory) click to toggle source
# File lib/packaging/repo.rb, line 123
def populate_repo_directory(artifact_parent_directory)
  cmd = "[ -d #{artifact_parent_directory}/artifacts ] || exit 1 ; "
  cmd << "pushd #{artifact_parent_directory} > /dev/null && "
  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}"
end
update_repo(remote_host, command, options = {}) click to toggle source
# File lib/packaging/repo.rb, line 136
def update_repo(remote_host, command, options = {})
  fail_message = "Error: Missing required argument '%s', update your 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_NAME__: options[:repo_name],
    __REPO_PATH__: options[:repo_path],
    __REPO_HOST__: options[:repo_host],
    __REPO_URL__: options[:repo_url],
    __APT_PLATFORMS__: Pkg::Config.apt_releases.join(' '),
    __GPG_KEY__: Pkg::Util::Gpg.key
  }
  Pkg::Util::Net.remote_execute(
    remote_host,
    Pkg::Util::Misc.search_and_replace(command, whitelist))
end
update_tarball_of_all_repos(project, platform, versioning) click to toggle source

Add a single repo tarball into the 'all' tarball located in 'pkg/<local_target>/<project>-all.tar' Create the 'all' tarball if needed.

# File lib/packaging/repo.rb, line 50
def update_tarball_of_all_repos(project, platform, versioning)
  tar = Pkg::Util::Tool.check_tool('tar')

  all_repos_tarball_name = "#{project}-all.tar"
  archive_name = "#{project}-#{platform['name']}"
  local_target = construct_local_target_path(project, versioning)
  repo_tarball_name = "#{archive_name}.tar.gz"
  repo_tarball_path = File.join('repos', repo_tarball_name)

  Dir.chdir(File.join('pkg', local_target)) do
    unless Pkg::Util::File.exist?(repo_tarball_path)
      warn "Skipping #{archive_name} because it (#{repo_tarball_path}) contains no files"
      next
    end

    tar_action = "--create"
    if File.exist?(all_repos_tarball_name)
      tar_action = "--update"
    end

    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
end