module PdkSync::Utils

Constants

NAME
OPERATINGSYSTEM
OPERATINGSYSTEMRELEASE
OPERATINGSYSTEM_SUPPORT
REQUIREMENTS

Public Class Methods

add_label(client, repo_name, issue_number, label) click to toggle source

@summary

This method when called will add a given label to a given repository

@param [PdkSync::GitPlatformClient] client

The Git Platform client used to gain access to and manipulate the repository.

@param [String] repo_name

The name of the repository on which the commit is to be made.

@param [Integer] issue_number

The id of the issue (i.e. pull request) to add the label to.

@param [String] label

The label to add.
# File lib/pdksync/utils.rb, line 54
def self.add_label(client, repo_name, issue_number, label)
  client.update_issue(repo_name, issue_number, labels: [label])
rescue StandardError => error
  PdkSync::Logger.info "Adding label to #{repo_name} issue #{issue_number} has failed. #{error}"
  return false
end
add_platform_to_metadata(module_path, os_to_add, version_to_add) click to toggle source

@summary

Adds an OS version to the supported platforms. Creates a new OS entry if it does not exist

@param module_path

Path to the root dir of the module

@param os_to_add

OS we want to add

@param version_to_add

Version we want to add
# File lib/pdksync/utils.rb, line 1187
def self.add_platform_to_metadata(module_path, os_to_add, version_to_add)
  os_to_add = normalize_os(os_to_add)
  new_metadata_json = metadata_json(module_path)
  updated_existing_entry = false
  new_metadata_json[OPERATINGSYSTEM_SUPPORT].each do |os_vers|
    next unless (os = normalize_os(os_vers[OPERATINGSYSTEM]))
    next unless os == os_to_add
    PdkSync::Logger.info "Adding #{os_to_add} version #{version_to_add} to existing entry"
    os_vers[OPERATINGSYSTEMRELEASE] << version_to_add
    os_vers[OPERATINGSYSTEMRELEASE].uniq!
    os_vers[OPERATINGSYSTEMRELEASE].sort_by!(&:to_f)
    updated_existing_entry = true
    break
  end
  unless updated_existing_entry
    PdkSync::Logger.info "Adding #{os_to_add} version #{version_to_add} to new entry"
    supported_platform_entry = {}
    supported_platform_entry[OPERATINGSYSTEM] = os_to_add
    supported_platform_entry[OPERATINGSYSTEMRELEASE] = [version_to_add]
    new_metadata_json[OPERATINGSYSTEM_SUPPORT] << supported_platform_entry
  end
  write_metadata_json(module_path, new_metadata_json)
end
add_provision_list(module_path, key, provisioner, images) click to toggle source

@summary

Adds an entry to the 'provision.yaml' of a module with the values given

@param [String] module_path

Path to the module root dir

@param [String] key

Key name in 'provision.yaml' (e.g. "release_checks_7)

@param [String] provisioner

The value for the provisioner key (e.g. "abs")

@param [Array] images

The list of images for the images key (e.g. ['ubuntu-1804-x86_64, ubuntu-2004-x86_64', 'centos-8-x86_64'])

@return [Boolean]

True if entry was successfully added to 'provision.yaml'
False if 'provision.yaml' does not exist or is an empty file
# File lib/pdksync/utils.rb, line 1015
def self.add_provision_list(module_path, key, provisioner, images)
  path_to_provision_yaml = "#{module_path}/provision.yaml"
  return false unless File.exist? path_to_provision_yaml
  PdkSync::Logger.info "Updating #{path_to_provision_yaml}"
  provision_yaml = YAML.safe_load(File.read(path_to_provision_yaml))
  return false if provision_yaml.nil?
  provision_yaml[key] = {}
  provision_yaml[key]['provisioner'] = provisioner
  provision_yaml[key]['images'] = images
  File.write(path_to_provision_yaml, YAML.dump(provision_yaml))
end
add_staged_files(git_repo) click to toggle source

@summary

This method when called will stage all changed files within the given repository, conditional on them being managed via the pdk.

@param [Git::Base] git_repo

A git object representing the local repository to be staged.
# File lib/pdksync/utils.rb, line 107
def self.add_staged_files(git_repo)
  if !git_repo.status.changed.empty?
    git_repo.add(all: true)
    PdkSync::Logger.info 'All files have been staged.'
    true
  else
    PdkSync::Logger.info 'Nothing to commit.'
    false
  end
end
adhoc_urls(job_name, jenkins_server_urls) click to toggle source

return jenkins job urls

# File lib/pdksync/utils.rb, line 798
def self.adhoc_urls(job_name, jenkins_server_urls)
  adhoc_urls = []
  # get adhoc jobs
  adhoc_urls.push("#{jenkins_server_urls}/job/#{job_name}")
  adhoc_urls.each do |url|
    conn = Faraday::Connection.new "#{url}/api/json"
    res = conn.get
    build_job_data = JSON.parse(res.body.to_s)
    downstream_job = build_job_data['downstreamProjects']
    break if downstream_job.empty?
    downstream_job.each do |item|
      next if item.nil?
      adhoc_urls.push(item['url']) unless item['url'].nil? && item['url'].include?('skippable_adhoc')
    end
  end
  adhoc_urls
end
analyse_jenkins_report(url, module_name, build_id) click to toggle source

analyse jenkins report

# File lib/pdksync/utils.rb, line 905
def self.analyse_jenkins_report(url, module_name, build_id)
  # builds don't have the same build_id. That's why just the init build will be identified by id, rest of them by lastBuild
  last_build_job_data = JSON.parse(Faraday.get("#{url}/#{build_id}/api/json").body.to_s) if url.include?('init-manual-parameters_adhoc')
  last_build_job_data = JSON.parse(Faraday.get("#{url}/lastBuild/api/json").body.to_s) unless url.include?('init-manual-parameters_adhoc')

  # status = 'not_built' unless last_build_job_data
  if last_build_job_data['result'].nil?
    status = 'in progress'
    execution_time = 'running'
  else
    status = last_build_job_data['result']
    execution_time = duration_hrs_and_mins(last_build_job_data['duration'].to_i)
  end

  # execution_time = 0 unless last_build_job_data
  logs_link = "#{url}/#{build_id}/" if url.include?('init-manual-parameters_adhoc')
  logs_link = "#{url}lastBuild/" unless url.include?('init-manual-parameters_adhoc')
  @data = "Job title =#{last_build_job_data['fullDisplayName']}\n logs_link = #{logs_link}\n status = #{status}\n"
  return_data = [status, execution_time]
  write_to_file("results_#{module_name}.out", @data)
  return_data
end
change_module_template_url(url, ref, metadata_file = 'metadata.json') click to toggle source

@param [String] - the url of the pdk-templates @param [String] - the ref of the pdk templates you want to change to @return [String] - the updated url

# File lib/pdksync/utils.rb, line 313
def self.change_module_template_url(url, ref, metadata_file = 'metadata.json')
  content = File.read(metadata_file)
  uri = PDK::Util::TemplateURI.uri_safe(url.to_s + "##{ref}")
  data_hash = JSON.parse(content)
  data_hash['template-url'] = uri
  File.write(metadata_file, data_hash.to_json)
  uri.to_s
end
check_for_label(client, repo_name, label) click to toggle source

@summary

This method when called will check on the given repository for the existence of the supplied label

@param [PdkSync::GitPlatformClient] client

The Git platform client used to gain access to and manipulate the repository.

@param [String] repo_name

The name of the repository on which the commit is to be made.

@param [String] label

The label to check for.

@return [Boolean]

A boolean stating whether the label was found.
# File lib/pdksync/utils.rb, line 71
def self.check_for_label(client, repo_name, label)
  # Get labels from repository
  repo_labels = client.labels(repo_name)

  # Look for label in the repository's labels
  match = false
  repo_labels.each do |repo_label|
    if repo_label.name == label
      match = true
      break
    end
  end

  # Raise error if a match was not found else return true
  (match == false) ? (raise StandardError, "Label '#{label}' not found in #{repo_name}") : (return true)
rescue StandardError => error
  PdkSync::Logger.fatal "Retrieving labels for #{repo_name} has failed. #{error}"
  return false
end
check_gem_latest_version(gem_to_test) click to toggle source

@summary

Check the most recent tagged release on GitHub for the gem

@param [String] gem_to_test

The gem to test
The current version of the gem
# File lib/pdksync/utils.rb, line 933
def self.check_gem_latest_version(gem_to_test)
  remote_version = Octokit.tags("puppetlabs/#{gem_to_test}").first[:name]
rescue StandardError => error
  puts "(WARNING) Unable to check latest gem version. #{error}".red
  remote_version
end
check_pdk_version() click to toggle source

@summary

Check the local pdk version against the most recent tagged release on GitHub

@return [Boolean] true if the remote version is less than or equal to local version

# File lib/pdksync/utils.rb, line 335
def self.check_pdk_version
  stdout, _stderr, status = Open3.capture3("#{return_pdk_path} --version")
  PdkSync::Logger.fatal "Unable to find pdk at '#{return_pdk_path}'." unless status.exitstatus
  local_version = stdout.strip
  remote_version = Octokit.tags('puppetlabs/pdk').first[:name][1..-1]
  up2date = Gem::Version.new(remote_version) <= Gem::Version.new(local_version)
  unless up2date
    PdkSync::Logger.warn "The current version of pdk is #{remote_version} however you are using #{local_version}"
  end
  up2date
rescue StandardError => error
  PdkSync::Logger.warn "Unable to check latest pdk version. #{error}"
end
checkout_branch(git_repo, branch_suffix) click to toggle source

@summary

This method when called will checkout a new local branch of the given repository.

@param [Git::Base] git_repo

A git object representing the local repository to be branched.

@param [String] branch_suffix

The string that is appended on the branch name. eg template_ref or a friendly name
# File lib/pdksync/utils.rb, line 328
def self.checkout_branch(git_repo, branch_suffix)
  git_repo.branch("pdksync_#{branch_suffix}").checkout
end
clean_env(output_path) click to toggle source

@summary

This method when called will call the delete function against the given repository if it exists.

@param [String] output_path

The repository that is to be deleted.
# File lib/pdksync/utils.rb, line 203
def self.clean_env(output_path)
  # If a local copy already exists it is removed
  FileUtils.rm_rf(output_path)
end
clone_directory(namespace, module_name, output_path) click to toggle source

@summary

This method when called will clone a given repository into a local location that has also been set.

@param [String] namespace

The namespace the repository is located in.

@param [String] module_name

The name of the repository.

@param [String] output_path

The location the repository is to be cloned to.

@return [Git::Base]

A git object representing the local repository or true if already exist
# File lib/pdksync/utils.rb, line 218
def self.clone_directory(namespace, module_name, output_path)
  # not all urls are public facing so we need to conditionally use the correct separator
  sep = configuration.git_base_uri.start_with?('git@') ? ':' : '/'
  clone_url = "#{configuration.git_base_uri}#{sep}#{namespace}/#{module_name}.git"
  Git.clone(clone_url, output_path.to_s)
rescue ::Git::GitExecuteError => error
  PdkSync::Logger.fatal "Cloning #{module_name} has failed. #{error}"
end
commit_staged_files(git_repo, template_ref, commit_message = nil) click to toggle source

@summary

This method when called will create a commit containing all currently staged files, with the name of the commit containing the template ref as a unique identifier.

@param [Git::Base] git_repo

A git object representing the local repository against which the commit is to be made.

@param [String] template_ref

The unique template_ref that is used as part of the commit name.

@param [String] commit_message

If specified it will be the message for the commit.
# File lib/pdksync/utils.rb, line 126
def self.commit_staged_files(git_repo, template_ref, commit_message = nil)
  message = if commit_message.nil?
              "pdksync_#{template_ref}"
            else
              commit_message
            end
  git_repo.commit(message)
end
configuration() click to toggle source
# File lib/pdksync/utils.rb, line 16
def self.configuration
  @configuration ||= PdkSync::Configuration.new
end
create_commit(git_repo, branch_name, commit_message) click to toggle source

@return

# File lib/pdksync/utils.rb, line 194
def self.create_commit(git_repo, branch_name, commit_message)
  checkout_branch(git_repo, branch_name)
  commit_staged_files(git_repo, branch_name, commit_message) if add_staged_files(git_repo)
end
create_filespace() click to toggle source

@summary

This method when called will create a directory identified by the set global variable 'configuration.pdksync_dir', on the condition that it does not already exist.
# File lib/pdksync/utils.rb, line 351
def self.create_filespace
  FileUtils.mkdir_p configuration.pdksync_dir unless Dir.exist?(configuration.pdksync_dir)
  configuration.pdksync_dir
end
create_filespace_gem() click to toggle source

@summary

This method when called will create a directory identified by the set global variable 'configuration.pdksync_gem_dir', on the condition that it does not already exist.
# File lib/pdksync/utils.rb, line 358
def self.create_filespace_gem
  FileUtils.mkdir_p configuration.pdksync_gem_dir unless Dir.exist?(configuration.pdksync_gem_dir)
  configuration.pdksync_gem_dir
end
create_pr(client, repo_name, template_ref, pdk_version, pr_title = nil) click to toggle source

@summary

This method when called will create a pr on the given repository that will create a pr to merge the given commit into the main with the pdk version as an identifier.

@param [PdkSync::GitPlatformClient] client

The Git platform client used to gain access to and manipulate the repository.

@param [String] repo_name

The name of the repository on which the commit is to be made.

@param [String] template_ref

The unique reference that that represents the template the update has ran against.

@param [String] pdk_version

The current version of the pdk on which the update is run.
# File lib/pdksync/utils.rb, line 159
def self.create_pr(client, repo_name, template_ref, pdk_version, pr_title = nil)
  if pr_title.nil?
    title = "pdksync - Update using #{pdk_version}"
    message = "pdk version: `#{pdk_version}` \n pdk template ref: `#{template_ref}`"
    head = "pdksync_#{template_ref}"
  else
    title = "pdksync - #{pr_title}"
    message = "#{pr_title}\npdk version: `#{pdk_version}` \n"
    head = template_ref
  end
  client.create_pull_request(repo_name, configuration.create_pr_against,
                             head,
                             title,
                             message)
rescue StandardError => error
  PdkSync::Logger.fatal "PR creation for #{repo_name} has failed. #{error}"
  nil
end
delete_branch(client, repo_name, branch_name) click to toggle source

@summary

This method when called will delete any preexisting branch on the given repository that matches the given name.

@param [PdkSync::GitPlatformClient] client

The Git platform client used to gain access to and manipulate the repository.

@param [String] repo_name

The name of the repository from which the branch is to be deleted.

@param [String] branch_name

The name of the branch that is to be deleted.
# File lib/pdksync/utils.rb, line 38
def self.delete_branch(client, repo_name, branch_name)
  client.delete_branch(repo_name, branch_name)
rescue StandardError => error
  PdkSync::Logger.fatal "Deleting #{branch_name} in #{repo_name} failed. #{error}"
end
duration_hrs_and_mins(ms) click to toggle source

convert duration from ms to format h m s ms

# File lib/pdksync/utils.rb, line 789
def self.duration_hrs_and_mins(ms)
  return '' unless ms
  hours, ms   = ms.divmod(1000 * 60 * 60)
  minutes, ms = ms.divmod(1000 * 60)
  seconds, ms = ms.divmod(1000)
  "#{hours}h #{minutes}m #{seconds}s #{ms}ms"
end
fetch_test_results_locally(output_path, module_type, module_name, report_rows) click to toggle source

@summary

This method when called will fetch the module tests results.

@param [String] output_path

The location that the command is to be run from.

@param [String] module_type

The module type (litmus or traditional)

@param [String] module_name

The module name

@param [String] report_rows

The module test results

@return [Integer]

The status code of the pdk update run.
# File lib/pdksync/utils.rb, line 618
def self.fetch_test_results_locally(output_path, module_type, module_name, report_rows)
  # Save the current path
  old_path = Dir.pwd
  if module_type != 'litmus'
    PdkSync::Logger.warn "(WARNING) Fetching test results locally supports only for litmus'"
  end

  # Run the tests
  Dir.chdir(old_path)
  lines = IO.readlines("#{output_path}/litmusacceptance.out")[-10..-1]
  if lines.find { |e| %r{exit} =~ e } # rubocop:disable Style/ConditionalAssignment
    report_rows << if lines.find { |e| %r{^Failed} =~ e } || lines.find { |e| %r{--trace} =~ e }
                     [module_name, 'FAILED', "Results are available in the following path #{output_path}/litmusacceptance.out"]
                   else
                     [module_name, 'SUCCESS', "Results are available in the following path #{output_path}/litmusacceptance.out"]
                   end
  else
    report_rows << if lines.find { |e| %r{^Failed} =~ e } || lines.find { |e| %r{--trace} =~ e } || lines.find { |e| %r{rake aborted} =~ e }
                     [module_name, 'FAILED', "Results are available in the following path #{output_path}/litmusacceptance.out"]
                   else
                     [module_name, 'PROGRESS', "Results will be available in the following path #{output_path}/litmusacceptance.out"]
                   end
  end
  return report_rows if module_type == 'litmus'
end
gem_file_update(output_path, gem_to_test, gem_line, gem_sha_finder, gem_sha_replacer, gem_version_finder, gem_version_replacer, gem_branch_finder, gem_branch_replacer, main_path) click to toggle source

@summary

This method when called will update a Gemfile and remove the existing version of gem from the Gemfile.

@param [String] output_path

The location that the command is to be run from.

@param [String] gem_to_test

The Gem to test.

@param [String] gem_line

The gem line to replace

@param [String] gem_sha_finder

The gem sha to find

@param [String] gem_sha_replacer

The gem sha to replace

@param [String] gem_version_finder

The gem version to find

@param [String] gem_version_replacer

The gem version to replace

@param [String] gem_branch_finder

The gem branch to find

@param [String] gem_branch_replacer

The gem branch to replace
# File lib/pdksync/utils.rb, line 436
def self.gem_file_update(output_path, gem_to_test, gem_line, gem_sha_finder, gem_sha_replacer, gem_version_finder, gem_version_replacer, gem_branch_finder, gem_branch_replacer, main_path)
  gem_file_name = 'Gemfile'
  validate_gem_update_module(gem_to_test, gem_line, output_path, main_path)

  if (gem_line.nil? == false) && (gem_sha_replacer != '\"\"')
    new_data = get_source_test_gem(gem_to_test, gem_line)
    new_data.each do |data|
      if data.include?('branch')
        gem_branch_replacer = data.split(' ')[1].strip.chomp('"').delete("'")
      elsif data.include?('ref')
        gem_sha_replacer = data.split(' ')[1].strip.chomp('').delete("'")
      elsif data =~ %r{~>|=|>=|<=|<|>}
        delimiters = ['>', '<', '>=', '<=', '=']
        version_to_check = data.split(Regexp.union(delimiters))[1].chomp('""').delete("'")
        validate_gem_version_replacer(version_to_check.to_s, gem_to_test)
      end
    end
  end

  if gem_sha_replacer.nil? == false && gem_sha_replacer != '\"\"' && gem_sha_replacer != ''
    validate_gem_sha_replacer(gem_sha_replacer.chomp('"').reverse.chomp('"').reverse, gem_to_test)
  end
  if gem_branch_replacer.nil? == false && gem_branch_replacer != '\"\"'
    validate_gem_branch_replacer(gem_branch_replacer.chomp('"').reverse.chomp('"').reverse, gem_to_test)
  end
  if gem_version_replacer.nil? == false && gem_version_replacer != '\"\"' && gem_version_replacer != ''
    delimiters = ['<', '>', '<=', '>=', '=']
    version_to_check = gem_version_replacer.split(Regexp.union(delimiters))
    version_to_check.each do |version|
      next if version.nil?
      validate_gem_version_replacer(version.to_s, gem_to_test) unless version == ''
    end
  end

  Dir.chdir(output_path) unless Dir.pwd == output_path

  line_number = 1
  gem_update_sha = [
    { finder: "ref: '#{gem_sha_finder}'",
      replacer: "ref: '#{gem_sha_replacer}'" }
  ]
  gem_update_version = [
    { finder: gem_version_finder,
      replacer: gem_version_replacer }
  ]
  gem_update_branch = [
    { finder: "branch: '#{gem_branch_finder}'",
      replacer: "branch: '#{gem_branch_replacer}'" }
  ]
  # gem_line option is passed

  if gem_line.nil? == false && (gem_line != '' || gem_line != '\"\"')

    # Delete the gem in the Gemfile to add the new line
    gem_test = gem_to_test.chomp('"').reverse.chomp('"').reverse
    File.open(temp_file_path, 'w') do |out_file|
      File.foreach(gem_file_name) do |line|
        out_file.puts line unless line =~ %r{#{gem_test}}
      end
    end
    FileUtils.mv(temp_file_path, gem_file_name)

    # Insert the new Gem to test
    file = File.open(gem_file_name)
    contents = file.readlines.map(&:chomp)
    contents.insert(line_number, gem_line.chomp('"').reverse.chomp('"').reverse)
    File.open(gem_file_name, 'w') { |f| f.write contents.join("\n") }
  end

  # gem_sha_finder and gem_sha_replacer options are passed
  if gem_sha_finder.nil? == false && gem_sha_replacer.nil? == false && gem_sha_finder != '' && gem_sha_finder != '\"\"' && gem_sha_replacer != '' && gem_sha_replacer != '\"\"'
    # Replace with SHA
    file = File.open(gem_file_name)
    contents = file.readlines.join
    gem_update_sha.each do |regex|
      contents = contents.gsub(%r{#{regex[:finder]}}, regex[:replacer])
    end
    File.open(gem_file_name, 'w') { |f| f.write contents.to_s }
  end

  # gem_version_finder and gem_version_replacer options are passed
  if gem_version_finder.nil? == false && gem_version_replacer.nil? == false && gem_version_finder != '' && gem_version_finder != '\"\"' && gem_version_replacer != '' && gem_version_replacer != '\"\"' # rubocop:disable Metrics/LineLength
    # Replace with version
    file = File.open(gem_file_name)
    contents = file.readlines.join
    gem_update_version.each do |regex|
      contents = contents.gsub(%r{#{regex[:finder]}}, regex[:replacer])
    end
    File.open(gem_file_name, 'w') { |f| f.write contents.to_s }
  end

  # gem_branch_finder and gem_branch_replacer options are passed
  if gem_branch_finder.nil? == false && gem_branch_replacer.nil? == false && gem_branch_finder != '' && gem_branch_finder != '\"\"' && gem_branch_replacer != '' && gem_branch_replacer != '\"\"' # rubocop:disable Metrics/LineLength, Style/GuardClause
    # Replace with branch
    file = File.open(gem_file_name)
    contents = file.readlines.join
    gem_update_branch.each do |regex|
      contents = contents.gsub(%r{#{regex[:finder]}}, regex[:replacer]) # unless contents =~ %r{#{gem_to_test}}
    end
    File.open(gem_file_name, 'w') { |f| f.write contents.to_s }
  end
end
generate_report_table(report_rows, url, data) click to toggle source

generate report table when running tests on jenkins

# File lib/pdksync/utils.rb, line 846
def self.generate_report_table(report_rows, url, data)
  if @failed
    report_rows << ['FAILED', url, data[1]] unless data.nil?
  elsif @aborted
    report_rows << ['ABORTED', url, data[1]] unless data.nil?
  else
    report_rows << [data[0], url, data[1]] unless data.nil?
  end
end
generate_vmpooler_release_checks(module_path, puppet_version) click to toggle source

@summary

Generate an entry in the 'provision.yaml' for running release checks against the platforms that the given
Puppet version. Will compare the supported platforms for the given Puppet version against the compatible
platforms defined in the module's 'metadata.json' and generate a list of platforms that are the same.

@param [String] module_path

Path to the module root dir

@param [String] puppet_version

Puppet version we are generating platform checks for
# File lib/pdksync/utils.rb, line 1253
def self.generate_vmpooler_release_checks(module_path, puppet_version)
  PdkSync::Logger.info "Generating release checks provision.yaml key for Puppet version #{puppet_version}"
  # This YAML is where the compatible platforms for each Puppet version is stored
  agent_test_platforms_yaml_file_path = 'lib/pdksync/conf/puppet_abs_supported_platforms.yaml'
  agent_test_platforms = YAML.safe_load(File.read(agent_test_platforms_yaml_file_path))
  raise "No configuration for Puppet #{puppet_version} found in #{agent_test_platforms_yaml_file_path}" unless agent_test_platforms.key? puppet_version
  agent_test_platforms = agent_test_platforms[puppet_version]
  module_supported_platforms = module_supported_platforms(module_path)
  images = []
  PdkSync::Logger.debug 'Processing compatible platforms from metadata.json'
  module_supported_platforms.each do |os_vers|
    os = os_vers['operatingsystem'].downcase
    # 'Windows' and 'OracleLinux' are the definitions in 'metadata.json', however the VMPooler images are 'win' and 'oracle'
    os = 'win' if os == 'windows'
    os = 'oracle' if os == 'oraclelinux'
    vers = os_vers['operatingsystemrelease']
    if agent_test_platforms.keys.select { |k| k.start_with? os }.empty?
      PdkSync::Logger.warn "'#{os}' is a compatible platform but was not defined as test platform for Puppet #{puppet_version} in #{agent_test_platforms_yaml_file_path}"
      next
    end
    vers.each do |ver|
      PdkSync::Logger.debug "Checking '#{os} #{ver}'"
      if os == 'win'
        win_ver = normalize_win_version(ver)
        PdkSync::Logger.debug "Normalised Windows version: #{win_ver}"
        next unless agent_test_platforms['win'].include? win_ver
        PdkSync::Logger.debug "'#{os} #{ver}' SUPPORTED by Puppet #{puppet_version}"
        images << "win-#{win_ver}-x86_64"
      else
        next unless agent_test_platforms[os].include? ver
        PdkSync::Logger.debug "'#{os} #{ver}' SUPPORTED by Puppet #{puppet_version}"
        images << "#{os}-#{ver.delete('.')}-x86_64"
      end
    end
  end
  images.uniq!
  result = add_provision_list(module_path, "release_checks_#{puppet_version}", 'abs', images)
  PdkSync::Logger.warn "#{module_path}/provision.yaml does not exist" unless result
end
get_data_build(url, build_id, module_name) click to toggle source

for each build from adhoc jobs, get data if multiple platforms under current url, get data for each platform

# File lib/pdksync/utils.rb, line 858
def self.get_data_build(url, build_id, module_name)
  current_build_data = JSON.parse(Faraday.get("#{url}/api/json").body.to_s)
  if current_build_data['activeConfigurations'].nil?
    returned_data = analyse_jenkins_report(url, module_name, build_id)
    if returned_data[0] == 'in progress'
      @in_progress = true
    elsif returned_data[0] == 'FAILURE'
      @failed = true
    elsif returned_data[0] == 'ABORTED'
      @aborted = true
    end
  else
    platforms_list = []
    current_build_data['activeConfigurations'].each do |url_child|
      next if url_child['color'] == 'notbuilt'
      platforms_list.push(url_child['url'])
    end

    platforms_list.each do |platform_build|
      returned_data = analyse_jenkins_report(platform_build, module_name, build_id)
      if returned_data[0] == 'in progress'
        @in_progress = true
      elsif returned_data[0] == 'FAILURE'
        @failed = true
      elsif returned_data[0] == 'ABORTED'
        @aborted = true
      end
    end
  end

  @data = "\nFAILURE. Fix the failures and rerun tests!\n" if @failed
  @data = "\nIN PROGRESS. Please check test report after the execution is done!\n" if @in_progress
  write_to_file("results_#{module_name}.out", @data) if @failed || @in_progress
  PdkSync::Logger.info 'Failed status! Fix errors and rerun.'.red if @failed
  PdkSync::Logger.info 'Aborted status! Fix errors and rerun.'.red if @aborted
  PdkSync::Logger.info 'Tests are still running! You can fetch the results later by using this task: test_results_jenkins'.blue if @in_progress
  returned_data
end
get_source_test_gem(gem_to_test, gem_line) click to toggle source

@summary

This method when called will find the source location of the gem to test

@param [String] gem_to_test

The gem to test

@param [String] gem_line

TThe line to update in the Gemfile

@return [String]

The source location of the gem to test
# File lib/pdksync/utils.rb, line 652
def self.get_source_test_gem(gem_to_test, gem_line)
  return gem_line.split(',') if gem_line
  return gem_to_test unless gem_to_test

  gemfile_line = File.readlines('Gemfile').find do |line|
    line.include?(gem_to_test.to_s)
  end

  return "https://github.com/puppetlabs/#{gem_to_test}" unless gemfile_line
  gemfile_line =~ %r{(http|https|ftp|ftps)\:\/\/[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(\/\S*)?}
  line.split(',')[1].strip.to_s if line
end
metadata_json(module_path) click to toggle source

@summary

Get the metadata.json of the given module

@param module_path

Path to the root dir of the module

@return [JSON]

JSON of the metadata.json
# File lib/pdksync/utils.rb, line 1106
def self.metadata_json(module_path)
  metadata_json = "#{module_path}/metadata.json"
  raise 'Could not locate metadata.json' unless File.exist? metadata_json
  JSON.parse(File.read(metadata_json))
end
module_supported_platforms(module_path) click to toggle source

@summary

Query the 'metadata.json' in the given module path and return the compatible platforms

@param [String] module_path

Path to the module root dir

@return [Hash]

The compatible OSs defined in the 'operatingsystem_support' key of the 'metadata.json'
# File lib/pdksync/utils.rb, line 1033
def self.module_supported_platforms(module_path)
  PdkSync::Logger.info 'Determining supported platforms from metadata.json'
  os_support_key = 'operatingsystem_support'
  metadata_json = "#{module_path}/metadata.json"
  raise 'Could not locate metadata.json' unless File.exist? metadata_json
  module_metadata = JSON.parse(File.read(metadata_json))
  raise "Could not locate '#{os_support_key}' key from #{metadata_json}" unless module_metadata.key? os_support_key
  module_metadata[os_support_key]
end
module_templates_url(metadata_file = 'metadata.json') click to toggle source

@summary

This method when called will retrieve the tempalate-url of the current module,

@param metadata_file [String]

An optional input that can be used to set the location of the metadata file.

@param url [String] - the url of the pdk-templates repo @return [String]

A string value that represents the current pdk tempalate-url.
# File lib/pdksync/utils.rb, line 304
def self.module_templates_url(metadata_file = 'metadata.json')
  file = File.read(metadata_file)
  data_hash = JSON.parse(file)
  data_hash['template-url']
end
module_type(output_path, repo_name) click to toggle source

@summary

This method is used to identify the type of module.

@param [String] output_path

The location that the command is to be run from.

@param [String] repo_name

The module name to identify the type
# File lib/pdksync/utils.rb, line 545
def self.module_type(output_path, repo_name)
  if repo_name.nil? == false
    module_type = if File.exist?("#{output_path}/provision.yaml")
                    'litmus'
                  else
                    'traditional'
                  end
  end
  module_type
end
normalize_metadata_supported_platforms(module_path) click to toggle source

@summary

Normalize the 'operatingsystem_support' entries in the metadata.json

@param module_path

Path to the root dir of the module
# File lib/pdksync/utils.rb, line 1132
def self.normalize_metadata_supported_platforms(module_path)
  new_metadata_json = metadata_json(module_path)

  new_metadata_json[OPERATINGSYSTEM_SUPPORT].each do |os_vers|
    normalized_os = normalize_os(os_vers[OPERATINGSYSTEM])
    unless normalized_os == os_vers[OPERATINGSYSTEM]
      PdkSync::Logger.info "Corrected OS Name: '#{os_vers[OPERATINGSYSTEM]}' -> '#{normalized_os}'"
      os_vers[OPERATINGSYSTEM] = normalized_os
    end
    next unless normalized_os == 'Windows'
    normalized_vers = os_vers[OPERATINGSYSTEMRELEASE].map { |v| normalize_win_version(v) }
    unless normalized_vers == os_vers[OPERATINGSYSTEMRELEASE]
      PdkSync::Logger.info "Corrected OS Versions: #{os_vers[OPERATINGSYSTEMRELEASE]} -> #{normalized_vers}"
      os_vers[OPERATINGSYSTEMRELEASE] = normalized_vers
    end
  end

  write_metadata_json(module_path, new_metadata_json)
end
normalize_os(os) click to toggle source

@summary

Normalize the given os name

@param os

The OS name to normalize

@return [String]

Normalized os name
# File lib/pdksync/utils.rb, line 1065
def self.normalize_os(os)
  case os
  when %r{aix}i
    'AIX'
  when %r{cent}i
    'CentOS'
  when %r{darwin}i
    'Darwin'
  when %r{deb}i
    'Debian'
  when %r{fedora}i
    'Fedora'
  when %r{oracle}i
    'OracleLinux'
  when %r{osx}i
    'OSX'
  when %r{pan}i
    'PAN-OS'
  when %r{red}i
    'RedHat'
  when %r{sci}i
    'Scientific'
  when %r{suse|sles}i
    'SLES'
  when %r{sol}i
    'Solaris'
  when %r{ubuntu}i
    'Ubuntu'
  when %r{win}i
    'Windows'
  else
    raise "Could not normalize OS value: #{os}"
  end
end
normalize_win_version(ver) click to toggle source

@summary

Take a Windows version extracted from the module's 'metadata.json' and normalize it to the version conventions
that VMPooler uses

@param ver

Version from 'metadata.json'

@return [String]

Normalised version that is used by VMPooler templates
# File lib/pdksync/utils.rb, line 1050
def self.normalize_win_version(ver)
  PdkSync::Logger.debug "Normalising Windows version from metadata.json: #{ver}"
  win_ver_matcher = ver.match(%r{(?:Server\s)?(?<ver>\d+)(?:\s(?<rel>R\d))?})
  raise "Unable to determine Windows version from metadata.json: #{ver}" unless win_ver_matcher
  normalized_version = win_ver_matcher['ver']
  normalized_version += " #{win_ver_matcher['rel'].upcase}" if win_ver_matcher['rel']
  normalized_version
end
on_windows?() click to toggle source
# File lib/pdksync/utils.rb, line 20
def self.on_windows?
  # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
  # library uses that to test what platform it's on.
  !!File::ALT_SEPARATOR # rubocop:disable Style/DoubleNegation
end
pdk_update(output_path) click to toggle source

@summary

This method when called will run the 'pdk update --force' command at the given location, with an error message being thrown if it is not successful.

@param [String] output_path

The location that the command is to be run from.

@return [Integer]

The status code of the pdk update run.
# File lib/pdksync/utils.rb, line 272
def self.pdk_update(output_path)
  # Runs the pdk update command
  Dir.chdir(output_path) do
    _, module_temp_ref = module_templates_url.split('#')
    module_temp_ref ||= configuration.pdk_templates_ref
    template_ref = configuration.module_is_authoritive ? module_temp_ref : configuration.pdk_templates_ref
    change_module_template_url(configuration.pdk_templates_url, template_ref) unless configuration.module_is_authoritive
    _stdout, stderr, status = Open3.capture3("#{return_pdk_path} update --force --template-ref=#{template_ref}")
    PdkSync::Logger.fatal "Unable to run `pdk update`: #{stderr}" unless status.exitstatus.zero?
    status.exitstatus
  end
end
push_staged_files(git_repo, current_branch, repo_name) click to toggle source

@summary

This method when called will push the given local commit to local repository's origin.

@param [Git::Base] git_repo

A git object representing the local repository againt which the push is to be made.

@param [String] template_ref

The unique reference that that represents the template the update has ran against.

@param [String] repo_name

The name of the repository on which the commit is to be made.
# File lib/pdksync/utils.rb, line 143
def self.push_staged_files(git_repo, current_branch, repo_name)
  git_repo.push(configuration.push_file_destination, current_branch)
rescue StandardError => error
  PdkSync::Logger.error "Pushing to #{configuration.push_file_destination} for #{repo_name} has failed. #{error}"
end
remove_platform_from_metadata(module_path, os_to_remove, version_to_remove) click to toggle source

@summary

Removes the OS version from the supported platforms
TODO: Remove entire OS entry when version is nil
TODO: Remove entire OS entry when versions is empty

@param module_path

Path to the root dir of the module

@param os_to_remove

OS we want to remove version from

@param version_to_remove

Version from OS we want to remove
# File lib/pdksync/utils.rb, line 1162
def self.remove_platform_from_metadata(module_path, os_to_remove, version_to_remove)
  new_metadata_json = metadata_json(module_path)
  new_metadata_json[OPERATINGSYSTEM_SUPPORT].each do |os_vers|
    if (os = normalize_os(os_vers[OPERATINGSYSTEM]))
      next unless os == os_to_remove
      vers = os_vers[OPERATINGSYSTEMRELEASE]
      next unless (ver_index = vers.find_index(version_to_remove))
      PdkSync::Logger.info "Removing #{os} #{vers[ver_index]} from metadata.json"
      vers.delete_at(ver_index)
    else
      PdkSync::Logger.info 'No entry in metadata.json to replace'
      return true
    end
  end
  write_metadata_json(module_path, new_metadata_json)
end
return_modules() click to toggle source

@summary

This method when called will access a file set by the global variable 'configuration.managed_modules' and retrieve the information within as an array.

@return [Array]

An array of different module names.
# File lib/pdksync/utils.rb, line 395
def self.return_modules
  raise "File '#{configuration.managed_modules}' is empty/does not exist" if File.size?(configuration.managed_modules).nil?
  YAML.safe_load(File.open(configuration.managed_modules))
end
return_pdk_path() click to toggle source

@summary

Try to use a fully installed pdk, otherwise fall back to the bundled pdk gem.

@return String

Path to the pdk executable
# File lib/pdksync/utils.rb, line 182
def self.return_pdk_path
  full_path = '/opt/puppetlabs/pdk/bin/pdk'
  path = if File.executable?(full_path)
           full_path
         else
           PdkSync::Logger.warn "(WARNING) Using pdk on PATH not '#{full_path}'"
           'pdk'
         end
  path
end
return_pdk_version(metadata_file = 'metadata.json') click to toggle source

@summary

This method when called will retrieve the pdk_version of the current module, i.e. the one that was navigated into in the 'pdk_update' method.

@param [String] metadata_file

An optional input that can be used to set the location of the metadata file.

@return [String]

A string value that represents the current pdk version.
# File lib/pdksync/utils.rb, line 97
def self.return_pdk_version(metadata_file = 'metadata.json')
  file = File.read(metadata_file)
  data_hash = JSON.parse(file)
  data_hash['pdk-version']
end
return_template_ref(metadata_file = 'metadata.json') click to toggle source

@summary

This method when called will retrieve the template ref of the current module, i.e. the one that was navigated into in the 'pdk_update' method.

@param [String] metadata_file

An optional input that can be used to set the location of the metadata file.

@return [String]

A string value that represents the current pdk template.
# File lib/pdksync/utils.rb, line 291
def self.return_template_ref(metadata_file = 'metadata.json')
  file = File.read(metadata_file)
  data_hash = JSON.parse(file)
  data_hash['template-ref']
end
run_command(output_path, command, option) click to toggle source

@summary

This method when called will run a command command at the given location, with an error message being thrown if it is not successful.

@param [String] output_path

The location that the command is to be run from.

@param [String] command

The command to be run.

@return [Integer]

The status code of the command run.
# File lib/pdksync/utils.rb, line 235
def self.run_command(output_path, command, option)
  stdout = ''
  stderr = ''
  status = Process::Status
  pid = ''
  Dir.chdir(output_path) unless Dir.pwd == output_path

  # Environment cleanup required due to Ruby subshells using current Bundler environment
  if option.nil? == true
    if command =~ %r{^bundle}
      Bundler.with_clean_env do
        stdout, stderr, status = Open3.capture3(command)
      end
    else
      stdout, stderr, status = Open3.capture3(command)
    end
    PdkSync::Logger.info "\n#{stdout}\n"
    PdkSync::Logger.crit "Unable to run command '#{command}': #{stderr}" unless status.exitstatus.zero?
    status.exitstatus
  else
    # Environment cleanup required due to Ruby subshells using current Bundler environment
    if command =~ %r{^sh }
      Bundler.with_clean_env do
        pid = spawn(command, out: 'run_command.out', err: 'run_command.err')
        Process.detach(pid)
      end
    end
    pid
  end
end
run_tests_jenkins(jenkins_client, repo_name, current_branch, github_user, job_name) click to toggle source

@summary

This method when called will create a pr on the given repository that will create a pr to merge the given commit into the main with the pdk version as an identifier.

@param [PdkSync::GitPlatformClient] client

The Git platform client used to gain access to and manipulate the repository.

@param [String] ouput_path

The location that the command is to be run from.

@param [String] jenkins_client

Jenkins authentication.

@param [String] repo_name

Module to run on Jenkins

@param [String] current_branch

The branch against which the user needs to run the jenkin jobs
# File lib/pdksync/utils.rb, line 776
def self.run_tests_jenkins(jenkins_client, repo_name, current_branch, github_user, job_name)
  if jenkins_client.nil? == false || repo_name.nil? == false || current_branch.nil? == false
    pr = jenkins_client.create_adhoc_job(repo_name,
                                         current_branch,
                                         github_user,
                                         job_name)
    pr
  end
rescue StandardError => error
  puts "(FAILURE) Jenkins Job creation for #{repo_name} has failed. #{error}".red
end
run_tests_locally(output_path, module_type, provision_type, module_name, puppet_collection) click to toggle source

@summary

This method when called will run the 'module tests' command at the given location, with an error message being thrown if it is not successful.

@param [String] output_path

The location that the command is to be run from.

@param [String] module_type

The module type (litmus or traditional)

@param [String] module_name

The module name

@param [String] puppet collection

The puppet collection

@return [Integer]

The status code of the pdk update run.
# File lib/pdksync/utils.rb, line 568
def self.run_tests_locally(output_path, module_type, provision_type, module_name, puppet_collection)
  provision_type = provision_type.chomp('"').reverse.chomp('"').reverse
  status = Process::Status
  # Save the current path
  old_path = Dir.pwd

  # Create the acceptance scripts
  file = File.open('acc.sh', 'w')
  file.puts '#!/bin/sh'

  if puppet_collection
    file.puts "export PUPPET_GEM_VERSION='~> #{puppet_collection}'"
  end
  file.puts "rm -rf #{output_path}/Gemfile.lock;rm -rf #{output_path}/.bundle"
  file.puts 'bundle install --path .bundle/gems/ --jobs 4'
  file.puts "bundle exec rake 'litmus:provision_list[#{provision_type}]'"
  file.puts 'bundle exec rake litmus:install_agent'
  file.puts 'bundle exec rake litmus:install_module'
  file.puts 'bundle exec rake litmus:acceptance:parallel'
  file.puts 'bundle exec rake litmus:tear_down'
  file.close

  # Runs the module tests command
  if module_type == 'litmus'
    run_command(output_path, 'cp ../../acc.sh .', nil)
    Dir.chdir(old_path)
    run_command(output_path, 'chmod 777 acc.sh', nil)
    Dir.chdir(old_path)
    status = run_command(output_path, 'sh acc.sh 2>&1 | tee litmusacceptance.out', 'background')
    if status != 0
      PdkSync::Logger.info "SUCCESS:Kicking of module Acceptance tests to run for the module #{module_name} - SUCCEED.Results will be available in the following path #{output_path}/litmusacceptance.out.Process id is #{status}"
    else
      PdkSync::Logger.fatal "FAILURE:Kicking of module Acceptance tests to run for the module #{module_name} - FAILED.Results will be available in the following path #{output_path}/litmusacceptance.out."
    end
  end
  PdkSync::Logger.warn "(WARNING) Executing testcases locally supports only for litmus'" if module_type != 'litmus'
end
setup_client() click to toggle source

@summary

This method when called will create and return an octokit client with access to the upstream git repositories.

@return [PdkSync::GitPlatformClient] client

The Git platform client that has been created.
# File lib/pdksync/utils.rb, line 367
def self.setup_client
  PdkSync::GitPlatformClient.new(configuration.git_platform, configuration.git_platform_access_settings)
rescue StandardError => error
  raise "Git platform access not set up correctly: #{error}"
end
setup_jenkins_client(jenkins_server_url) click to toggle source

@summary

This method when called will create and return an octokit client with access to jenkins.

@return [PdkSync::JenkinsClient] client

The Git platform client that has been created.
# File lib/pdksync/utils.rb, line 377
def self.setup_jenkins_client(jenkins_server_url)
  require 'pdksync/jenkinsclient'
  if configuration.jenkins_platform_access_settings[:jenkins_username].nil?
    raise ArgumentError, "Jenkins access token for #{configuration.jenkins_platform.capitalize} not set"\
        " - use 'export #{configuration.jenkins_platform.upcase}_USERNAME=\"<your username>\"' to set"
  elsif configuration.jenkins_platform_access_settings[:jenkins_password].nil?
    raise ArgumentError, "Jenkins access token for #{jenkins_platform.capitalize} not set"\
    " - use 'export #{jenkins_platform.upcase}_PASSWORD=\"<your password>\"' to set"
  end
  PdkSync::JenkinsClient.new(jenkins_server_url, configuration.jenkins_platform_access_settings)
rescue StandardError => error
  raise "Jenkins platform access not set up correctly: #{error}"
end
temp_file_path() click to toggle source
# File lib/pdksync/utils.rb, line 26
def self.temp_file_path
  @temp_file_path ||= on_windows? ? "#{ENV['TEMP']}\\out.tmp" : '/tmp/out.tmp'
end
test_results_jenkins(jenkins_server_url, build_id, job_name, module_name) click to toggle source

test_results_jenkins

# File lib/pdksync/utils.rb, line 817
def self.test_results_jenkins(jenkins_server_url, build_id, job_name, module_name)
  PdkSync::Logger.info 'Fetch results from jenkins'
  # remove duplicates and sort the list
  adhoc_urls = adhoc_urls(job_name, jenkins_server_url).uniq.sort_by { |url| JSON.parse(Faraday.get("#{url}/api/json").body.to_s)['fullDisplayName'].scan(%r{[0-9]{2}\s}).first.to_i }
  report_rows = []
  @failed = false
  @in_progress = false
  @aborted = false

  File.delete("results_#{module_name}.out") if File.exist?("results_#{module_name}.out")
  # analyse each build result - get status, execution time, logs_link
  @data = "MODULE_NAME=#{module_name}\nBUILD_ID=#{build_id}\nINITIAL_job=#{jenkins_server_url}/job/#{job_name}/#{build_id}\n\n"
  write_to_file("results_#{module_name}.out", @data)
  PdkSync::Logger.info "Analyse test execution report \n"
  adhoc_urls.each do |url|
    # next if skipped in build name
    current_build_data = JSON.parse(Faraday.get("#{url}/api/json").body.to_s)
    next if url.include?('skippable_adhoc') || current_build_data['color'] == 'notbuilt'
    next if current_build_data['fullDisplayName'].downcase.include?('skipped')
    returned_data = get_data_build(url, build_id, module_name) unless @failed || @in_progress
    generate_report_table(report_rows, url, returned_data)
  end

  table = Terminal::Table.new title: "Module Test Results for: #{module_name}\nCheck results in #{Dir.pwd}/results_#{module_name}.out ", headings: %w[Status Result Execution_Time], rows: report_rows
  PdkSync::Logger.info "SUCCESSFUL test results!\n".green unless @failed || @in_progress
  PdkSync::Logger.info "\n#{table} \n"
end
update_gem_latest_version_by_one(gem_version) click to toggle source

@summary

Update the gem version by one

@param [String] gem_version

The current version of the gem
The bump version by one of the gem
# File lib/pdksync/utils.rb, line 945
def self.update_gem_latest_version_by_one(gem_version)
  current_version = Gem::Version.new gem_version
  new_version = current_version.bump
rescue StandardError => error
  puts "(WARNING) Unable to check latest gem version. #{error}".red
  new_version
end
update_gemfile_multigem(output_path, gem_name, gemfury_token, gemfury_user) click to toggle source

@summary

Update Gemfile with multigem

@param [String] output_path

The location that the command is to be run from.

@param [String] gem_name

The gem name

@param [String] gemfury_token

The gemfury token

@param [String] gemfury_user

The gemfury user
# File lib/pdksync/utils.rb, line 963
def self.update_gemfile_multigem(output_path, gem_name, gemfury_token, gemfury_user)
  gem_file_name = 'Gemfile'
  gem_source_line = "source \"https://#{gemfury_token}@gem.fury.io/#{gemfury_user}/\""
  Dir.chdir(output_path) unless Dir.pwd == output_path

  if gem_name.nil? == false && gemfury_token.nil? == false && gemfury_user.nil? == false # rubocop:disable Style/GuardClause
    # Append the gem with new source location
    gem_name = gem_name.chomp('"').reverse.chomp('"').reverse
    begin
      File.open(temp_file_path, 'w') do |out_file|
        File.foreach(gem_file_name) do |line|
          if line =~ %r{#{gem_name}}
            line = line.chomp
            if line =~ %r{"https://#{gemfury_token}@gem.fury.io/#{gemfury_user}/"}
              puts 'GemFile Already updated'.green
              out_file.puts line.to_s
            else
              out_file.puts "#{line} , :source => \"https://#{gemfury_token}@gem.fury.io/#{gemfury_user}/\""
            end
          else
            out_file.puts line
          end
        end
      end
      FileUtils.mv(temp_file_path, gem_file_name)

      # Insert the new source Gem location to Gemfile
      file = File.open(gem_file_name)
      contents = file.readlines.map(&:chomp)
      contents.insert(2, gem_source_line) unless contents.include?(gem_source_line)
      File.open(gem_file_name, 'w') { |f| f.write contents.join("\n") }
    rescue Errno::ENOENT => e
      raise "Couldn't find file: #{gem_file_name} #{e} in your repository: #{gem_file_name}".red
    rescue Errno::EACCES => e
      raise "Does not have required permissions to the #{gem_file_name} #{e} in your repository: #{gem_file_name}".red
    end
  end
end
update_requirements(module_path, name, key, value) click to toggle source

@summary

Updates the requirements parameter in the metadata.json. If the requirement or  a key within it doesn't exist,
it is created.
TODO: Ability to remove requirement

@param module_path

Path to the root dir of the module

@param name

Name attribute of the requirement

@param key

The key name of a K/V pair to be added / updated in the requirement

@param value

The value of the key to be added / updated in the requirement
# File lib/pdksync/utils.rb, line 1226
def self.update_requirements(module_path, name, key, value)
  new_metadata_json = metadata_json(module_path)
  updated_existing_entry = false
  new_metadata_json[REQUIREMENTS].each do |requirement|
    next unless requirement[NAME] == name
    PdkSync::Logger.info "Updating [#{requirement['name']}] #{requirement.key? key ? "dependency's existing" : 'with a new'} key [#{key}] to value [#{value}]"
    requirement[key] = value
    updated_existing_entry = true
  end
  unless updated_existing_entry
    PdkSync::Logger.info "Adding new requirement [#{name}] with key [#{key}] of value [#{value}]"
    new_requirement = {}
    new_requirement[NAME] = name
    new_requirement[key] = value
    new_metadata_json[REQUIREMENTS] << new_requirement
  end
  write_metadata_json(module_path, new_metadata_json)
end
validate_gem_branch_replacer(gem_branch_replacer, gem_to_test) click to toggle source

@summary

This method when called will validate the gem_branch_replacer to update in the Gemfile

@param [String] gem_to_test

The gem to test

@param [String] gem_branch_replacer

The branch to update in the Gemfile
# File lib/pdksync/utils.rb, line 744
def self.validate_gem_branch_replacer(gem_branch_replacer, gem_to_test)
  raise "Couldn't find branch: #{gem_branch_replacer} in your repository: #{gem_to_test}".red unless @all_branches.include?(gem_branch_replacer)
  puts "Branch #{gem_branch_replacer} valid.\n".green
end
validate_gem_sha_replacer(gem_sha_replacer, gem_to_test) click to toggle source

@summary

This method when called will validate the gem_sha_replacer to update in the Gemfile

@param [String] gem_to_test

The gem to test

@param [String] gem_sha_replacer

The sha to update in the Gemfile
# File lib/pdksync/utils.rb, line 729
def self.validate_gem_sha_replacer(gem_sha_replacer, gem_to_test)
  found = false
  @all_refs.split(' ').each do |sha|
    puts "SHA #{gem_sha_replacer} valid.\n".green if gem_sha_replacer == sha
    found = true if gem_sha_replacer == sha
  end
  raise "Couldn't find sha: #{gem_sha_replacer} in your repository: #{gem_to_test}".red if found == false
end
validate_gem_update_module(gem_to_test, gem_line, output_path, main_path) click to toggle source

@summary

This method when called will validate the gem_line to update in the Gemfile

@param [String] gem_to_test

The gem to test

@param [String] gem_line

The line to update in the Gemfile
# File lib/pdksync/utils.rb, line 671
def self.validate_gem_update_module(gem_to_test, gem_line, output_path, main_path)
  gem_to_test = gem_to_test.chomp('"').reverse.chomp('"').reverse
  Dir.chdir(main_path)
  output_path = "#{configuration.pdksync_dir}/#{gem_to_test}"
  clean_env(output_path) if Dir.exist?(output_path)
  print 'delete module directory, '

  # when gem_line is specified, we need to parse the line and identify all the values
  # - we can have source url or we need to
  # - sha, branch, version
  if gem_line
    git_repo = get_source_test_gem(gem_to_test, gem_line)
    i = 0
    git_repo.each do |item|
      i += 1
      if item =~ %r{((git@|http(s)?:\/\/)([\w\.@]+)(\/|:))([\w,\-,\_]+)\/([\w,\-,\_]+)(.git){0,1}((\/){0,1})}
        git_repo = item.split('git:')[1].strip.delete("'")
        break
      elsif git_repo.size == i
        # git_repo = "https://github.com/puppetlabs#{gem_to_test}"
        sep = configuration.git_base_uri.start_with?('git@') ? ':' : '/'
        git_repo = "#{configuration.git_base_uri}#{sep}#{configuration.namespace}/#{gem_to_test}"
      end
    end
    print 'clone module directory, '
    git_repo = run_command(configuration.pdksync_dir.to_s, "git clone #{git_repo}", nil)
  elsif gem_to_test
    git_repo = clone_directory(configuration.namespace, gem_to_test, output_path.to_s)
  end

  Dir.chdir(main_path)
  raise "Unable to clone repo for #{gem_to_test}. Check repository's url to be correct!".red if git_repo.nil?

  @all_versions = ''
  @all_refs = ''
  @all_branches = ''

  Dir.chdir(output_path)

  stdout_refs, stderr_refs, status_refs = Open3.capture3('git show-ref -s')
  @all_refs = stdout_refs
  stdout_branches, stderr_branches, status_branches = Open3.capture3('git branch -a')
  @all_branches = stdout_branches
  stdout_versions, stderr_versions, status_versions = Open3.capture3('git tag')
  @all_versions = stdout_versions

  raise "Couldn't get references due to #{stderr_refs}".red unless status_refs.exitstatus.zero?
  raise "Couldn't get branches due to #{stderr_branches}".red unless status_branches.exitstatus.zero?
  raise "Couldn't get versions due to #{stderr_versions}".red unless status_versions.exitstatus.zero?
  Dir.chdir(main_path)
end
validate_gem_version_replacer(gem_version_replacer, gem_to_test) click to toggle source

@summary

This method when called will validate the gem_version_replacer to update in the Gemfile

@param [String] gem_to_test

The gem to test

@param [String] gem_version_replacer

The version to update in the Gemfile
# File lib/pdksync/utils.rb, line 755
def self.validate_gem_version_replacer(gem_version_replacer, gem_to_test)
  found = false
  @all_versions.split(' ').each do |version|
    puts "Version #{gem_version_replacer} valid.\n".green if gem_version_replacer == version
    found = true if gem_version_replacer == version
  end
  raise "Couldn't find version: #{gem_version_replacer} in your repository: #{gem_to_test}".red if found == false
end
validate_modules_exist(client, module_names) click to toggle source

@summary

This method when called will parse an array of module names and verify
whether they are valid repo or project names on the configured Git
hosting platform.

@param [PdkSync::GitPlatformClient] client

The Git platform client used to get a repository.

@param [Array] module_names

String array of the names of Git platform repos
# File lib/pdksync/utils.rb, line 408
def self.validate_modules_exist(client, module_names)
  raise "Error reading in modules. Check syntax of '#{configuration.managed_modules}'." unless !module_names.nil? && module_names.is_a?(Array)
  invalid = module_names.reject { |name| client.repository?("#{configuration.namespace}/#{name}") }
  # Raise error if any invalid matches were found
  raise "Could not find the following repositories: #{invalid}" unless invalid.empty?
  true
end
write_metadata_json(module_path, metadata_json) click to toggle source

@summary

Write the given metadata in JSON format to the given module root dir path

@param module_path

Path to the root dir of the module

@param metadata_json

Metadata in JSON format to write to the module root dir
# File lib/pdksync/utils.rb, line 1122
def self.write_metadata_json(module_path, metadata_json)
  File.open(File.join(module_path, 'metadata.json'), 'w') do |f|
    f.write(JSON.pretty_generate(metadata_json) + "\n")
  end
end
write_to_file(file, _data) click to toggle source

write test report to file

# File lib/pdksync/utils.rb, line 898
def self.write_to_file(file, _data)
  File.open(file, 'a') do |f|
    f.write @data
  end
end