Module: PdkSync::Utils

Defined in:
lib/pdksync/utils.rb

Constant Summary collapse

OPERATINGSYSTEM = 
'operatingsystem'.freeze
OPERATINGSYSTEMRELEASE = 
'operatingsystemrelease'.freeze
OPERATINGSYSTEM_SUPPORT = 
'operatingsystem_support'.freeze
NAME = 
'name'.freeze
REQUIREMENTS = 
'requirements'.freeze

Class Method Summary collapse

Class Method Details

.add_label(client, repo_name, issue_number, label) ⇒ Object

Parameters:

  • client (PdkSync::GitPlatformClient) —

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

  • repo_name (String) —

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

  • issue_number (Integer) —

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

  • label (String) —

    The label to add.



53
54
55
56
57
58
 
# File 'lib/pdksync/utils.rb', line 53

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) ⇒ Object

Parameters:

  • module_path —

    Path to the root dir of the module

  • os_to_add —

    OS we want to add

  • version_to_add —

    Version we want to add



1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
 
# File 'lib/pdksync/utils.rb', line 1190

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) ⇒ Boolean

Returns True if entry was successfully added to ‘provision.yaml’ False if ‘provision.yaml’ does not exist or is an empty file.

Parameters:

  • module_path (String) —

    Path to the module root dir

  • key (String) —

    Key name in ‘provision.yaml’ (e.g. “release_checks_7)

  • provisioner (String) —

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

  • images (Array) —

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

Returns:

  • (Boolean) —

    True if entry was successfully added to ‘provision.yaml’ False if ‘provision.yaml’ does not exist or is an empty file



1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
 
# File 'lib/pdksync/utils.rb', line 1014

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) ⇒ Object

Parameters:

  • git_repo (Git::Base) —

    A git object representing the local repository to be staged.



106
107
108
109
110
111
112
113
114
115
 
# File 'lib/pdksync/utils.rb', line 106

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) ⇒ Object

return jenkins job urls



797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
 
# File 'lib/pdksync/utils.rb', line 797

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) ⇒ Object

analyse jenkins report



904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
 
# File 'lib/pdksync/utils.rb', line 904

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') ⇒ String

Returns - the updated url.

Parameters:

  • - (String) —

    the url of the pdk-templates

  • - (String) —

    the ref of the pdk templates you want to change to

Returns:

  • (String) —

    • the updated url



312
313
314
315
316
317
318
319
 
# File 'lib/pdksync/utils.rb', line 312

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) ⇒ Boolean

Returns A boolean stating whether the label was found.

Parameters:

  • client (PdkSync::GitPlatformClient) —

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

  • repo_name (String) —

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

  • label (String) —

    The label to check for.

Returns:

  • (Boolean) —

    A boolean stating whether the label was found.



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/pdksync/utils.rb', line 70

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) ⇒ Object

Parameters:

  • gem_to_test (String) —

    The gem to test The current version of the gem



932
933
934
935
936
937
 
# File 'lib/pdksync/utils.rb', line 932

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 ⇒ Boolean

Returns true if the remote version is less than or equal to local version.

Returns:

  • (Boolean) —

    true if the remote version is less than or equal to local version



334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/pdksync/utils.rb', line 334

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) ⇒ Object

Parameters:

  • git_repo (Git::Base) —

    A git object representing the local repository to be branched.

  • branch_suffix (String) —

    The string that is appended on the branch name. eg template_ref or a friendly name



327
328
329
 
# File 'lib/pdksync/utils.rb', line 327

def self.checkout_branch(git_repo, branch_suffix)
  git_repo.branch("pdksync_#{branch_suffix}").checkout
end

.clean_env(output_path) ⇒ Object

Parameters:

  • output_path (String) —

    The repository that is to be deleted.



202
203
204
205
 
# File 'lib/pdksync/utils.rb', line 202

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) ⇒ Git::Base

Returns A git object representing the local repository or true if already exist.

Parameters:

  • namespace (String) —

    The namespace the repository is located in.

  • module_name (String) —

    The name of the repository.

  • output_path (String) —

    The location the repository is to be cloned to.

Returns:

  • (Git::Base) —

    A git object representing the local repository or true if already exist



217
218
219
220
221
222
223
224
 
# File 'lib/pdksync/utils.rb', line 217

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) ⇒ Object

Parameters:

  • git_repo (Git::Base) —

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

  • template_ref (String) —

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

  • commit_message (String) (defaults to: nil) —

    If specified it will be the message for the commit.



125
126
127
128
129
130
131
132
 
# File 'lib/pdksync/utils.rb', line 125

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 ⇒ Object 



15
16
17
 
# File 'lib/pdksync/utils.rb', line 15

def self.configuration
  @configuration ||= PdkSync::Configuration.new
end

.create_commit(git_repo, branch_name, commit_message) ⇒ Object

Returns:



193
194
195
196
 
# File 'lib/pdksync/utils.rb', line 193

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 ⇒ Object 



350
351
352
353
 
# File 'lib/pdksync/utils.rb', line 350

def self.create_filespace
  FileUtils.mkdir_p configuration.pdksync_dir unless Dir.exist?(configuration.pdksync_dir)
  configuration.pdksync_dir
end

.create_filespace_gem ⇒ Object 



357
358
359
360
 
# File 'lib/pdksync/utils.rb', line 357

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) ⇒ Object

Parameters:

  • client (PdkSync::GitPlatformClient) —

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

  • repo_name (String) —

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

  • template_ref (String) —

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

  • pdk_version (String) —

    The current version of the pdk on which the update is run.



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/pdksync/utils.rb', line 158

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) ⇒ Object

Parameters:

  • client (PdkSync::GitPlatformClient) —

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

  • repo_name (String) —

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

  • branch_name (String) —

    The name of the branch that is to be deleted.



37
38
39
40
41
 
# File 'lib/pdksync/utils.rb', line 37

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) ⇒ Object

convert duration from ms to format h m s ms



788
789
790
791
792
793
794
 
# File 'lib/pdksync/utils.rb', line 788

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) ⇒ Integer

Returns The status code of the pdk update run.

Parameters:

  • output_path (String) —

    The location that the command is to be run from.

  • module_type (String) —

    The module type (litmus or traditional)

  • module_name (String) —

    The module name

  • report_rows (String) —

    The module test results

Returns:

  • (Integer) —

    The status code of the pdk update run.



617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
 
# File 'lib/pdksync/utils.rb', line 617

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) ⇒ Object

Parameters:

  • output_path (String) —

    The location that the command is to be run from.

  • gem_to_test (String) —

    The Gem to test.

  • gem_line (String) —

    The gem line to replace

  • gem_sha_finder (String) —

    The gem sha to find

  • gem_sha_replacer (String) —

    The gem sha to replace

  • gem_version_finder (String) —

    The gem version to find

  • gem_version_replacer (String) —

    The gem version to replace

  • gem_branch_finder (String) —

    The gem branch to find

  • gem_branch_replacer (String) —

    The gem branch to replace



435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
 
# File 'lib/pdksync/utils.rb', line 435

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) ⇒ Object

generate report table when running tests on jenkins



845
846
847
848
849
850
851
852
853
 
# File 'lib/pdksync/utils.rb', line 845

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) ⇒ Object

Parameters:

  • module_path (String) —

    Path to the module root dir

  • puppet_version (String) —

    Puppet version we are generating platform checks for



1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
 
# File 'lib/pdksync/utils.rb', line 1256

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) ⇒ Object

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



857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
 
# File 'lib/pdksync/utils.rb', line 857

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) ⇒ String

Returns The source location of the gem to test.

Parameters:

  • gem_to_test (String) —

    The gem to test

  • gem_line (String) —

    TThe line to update in the Gemfile

Returns:

  • (String) —

    The source location of the gem to test



651
652
653
654
655
656
657
658
659
660
661
662
 
# File 'lib/pdksync/utils.rb', line 651

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) ⇒ JSON

Returns JSON of the metadata.json.

Parameters:

  • module_path —

    Path to the root dir of the module

Returns:

  • (JSON) —

    JSON of the metadata.json



1109
1110
1111
1112
1113
 
# File 'lib/pdksync/utils.rb', line 1109

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) ⇒ Hash

Returns The compatible OSs defined in the ‘operatingsystem_support’ key of the ‘metadata.json’.

Parameters:

  • module_path (String) —

    Path to the module root dir

Returns:

  • (Hash) —

    The compatible OSs defined in the ‘operatingsystem_support’ key of the ‘metadata.json’



1032
1033
1034
1035
1036
1037
1038
1039
1040
 
# File 'lib/pdksync/utils.rb', line 1032

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') ⇒ String

Returns A string value that represents the current pdk tempalate-url.

Parameters:

  • metadata_file (String) (defaults to: 'metadata.json') —

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

  • url (String) —

    • the url of the pdk-templates repo

Returns:

  • (String) —

    A string value that represents the current pdk tempalate-url.



303
304
305
306
307
 
# File 'lib/pdksync/utils.rb', line 303

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) ⇒ Object

Parameters:

  • output_path (String) —

    The location that the command is to be run from.

  • repo_name (String) —

    The module name to identify the type



544
545
546
547
548
549
550
551
552
553
 
# File 'lib/pdksync/utils.rb', line 544

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) ⇒ Object

Parameters:

  • module_path —

    Path to the root dir of the module



1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
 
# File 'lib/pdksync/utils.rb', line 1135

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) ⇒ String

Returns Normalized os name.

Parameters:

  • os —

    The OS name to normalize

Returns:

  • (String) —

    Normalized os name



1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
 
# File 'lib/pdksync/utils.rb', line 1064

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'
  when %r{rocky}i
    'Rocky'
  when %r{almalinux}i
    'AlmaLinux'
  else
    raise "Could not normalize OS value: #{os}"
  end
end

.normalize_win_version(ver) ⇒ String

Returns Normalised version that is used by VMPooler templates.

Parameters:

  • ver —

    Version from ‘metadata.json’

Returns:

  • (String) —

    Normalised version that is used by VMPooler templates



1049
1050
1051
1052
1053
1054
1055
1056
 
# File 'lib/pdksync/utils.rb', line 1049

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? ⇒ Boolean

Returns:

  • (Boolean) 


19
20
21
22
23
 
# File 'lib/pdksync/utils.rb', line 19

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) ⇒ Integer

Returns The status code of the pdk update run.

Parameters:

  • output_path (String) —

    The location that the command is to be run from.

Returns:

  • (Integer) —

    The status code of the pdk update run.



271
272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/pdksync/utils.rb', line 271

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) ⇒ Object

Parameters:

  • git_repo (Git::Base) —

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

  • template_ref (String) —

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

  • repo_name (String) —

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



142
143
144
145
146
 
# File 'lib/pdksync/utils.rb', line 142

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) ⇒ Object

Parameters:

  • module_path —

    Path to the root dir of the module

  • os_to_remove —

    OS we want to remove version from

  • version_to_remove —

    Version from OS we want to remove



1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
 
# File 'lib/pdksync/utils.rb', line 1165

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 ⇒ Array

Returns An array of different module names.

Returns:

  • (Array) —

    An array of different module names.



394
395
396
397
 
# File 'lib/pdksync/utils.rb', line 394

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 ⇒ Object

Returns String Path to the pdk executable.

Returns:

  • String Path to the pdk executable



181
182
183
184
185
186
187
188
189
190
 
# File 'lib/pdksync/utils.rb', line 181

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') ⇒ String

Returns A string value that represents the current pdk version.

Parameters:

  • metadata_file (String) (defaults to: 'metadata.json') —

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

Returns:

  • (String) —

    A string value that represents the current pdk version.



96
97
98
99
100
 
# File 'lib/pdksync/utils.rb', line 96

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') ⇒ String

Returns A string value that represents the current pdk template.

Parameters:

  • metadata_file (String) (defaults to: 'metadata.json') —

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

Returns:

  • (String) —

    A string value that represents the current pdk template.



290
291
292
293
294
 
# File 'lib/pdksync/utils.rb', line 290

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) ⇒ Integer

Returns The status code of the command run.

Parameters:

  • output_path (String) —

    The location that the command is to be run from.

  • command (String) —

    The command to be run.

Returns:

  • (Integer) —

    The status code of the command run.



234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
 
# File 'lib/pdksync/utils.rb', line 234

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.error "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) ⇒ Object

Parameters:

  • client (PdkSync::GitPlatformClient) —

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

  • ouput_path (String) —

    The location that the command is to be run from.

  • jenkins_client (String) —

    Jenkins authentication.

  • repo_name (String) —

    Module to run on Jenkins

  • current_branch (String) —

    The branch against which the user needs to run the jenkin jobs



775
776
777
778
779
780
781
782
783
784
785
 
# File 'lib/pdksync/utils.rb', line 775

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) ⇒ Integer

Returns The status code of the pdk update run.

Parameters:

  • output_path (String) —

    The location that the command is to be run from.

  • module_type (String) —

    The module type (litmus or traditional)

  • module_name (String) —

    The module name

  • puppet (String) —

    collection The puppet collection

Returns:

  • (Integer) —

    The status code of the pdk update run.



567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
 
# File 'lib/pdksync/utils.rb', line 567

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 ⇒ PdkSync::GitPlatformClient

Returns client The Git platform client that has been created.

Returns:



366
367
368
369
370
 
# File 'lib/pdksync/utils.rb', line 366

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) ⇒ PdkSync::JenkinsClient

Returns client The Git platform client that has been created.

Returns:



376
377
378
379
380
381
382
383
384
385
386
387
388
 
# File 'lib/pdksync/utils.rb', line 376

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 ⇒ Object 



25
26
27
 
# File 'lib/pdksync/utils.rb', line 25

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) ⇒ Object

test_results_jenkins



816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
 
# File 'lib/pdksync/utils.rb', line 816

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) ⇒ Object

Parameters:

  • gem_version (String) —

    The current version of the gem The bump version by one of the gem



944
945
946
947
948
949
950
 
# File 'lib/pdksync/utils.rb', line 944

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) ⇒ Object

Parameters:

  • output_path (String) —

    The location that the command is to be run from.

  • gem_name (String) —

    The gem name

  • gemfury_token (String) —

    The gemfury token

  • gemfury_user (String) —

    The gemfury user



962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
 
# File 'lib/pdksync/utils.rb', line 962

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) ⇒ Object

Parameters:

  • module_path —

    Path to the root dir of the module

  • name —

    Name attribute of the requirement

  • key —

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

  • value —

    The value of the key to be added / updated in the requirement



1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
 
# File 'lib/pdksync/utils.rb', line 1229

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) ⇒ Object

Parameters:

  • gem_to_test (String) —

    The gem to test

  • gem_branch_replacer (String) —

    The branch to update in the Gemfile



743
744
745
746
 
# File 'lib/pdksync/utils.rb', line 743

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) ⇒ Object

Parameters:

  • gem_to_test (String) —

    The gem to test

  • gem_sha_replacer (String) —

    The sha to update in the Gemfile



728
729
730
731
732
733
734
735
 
# File 'lib/pdksync/utils.rb', line 728

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) ⇒ Object

Parameters:

  • gem_to_test (String) —

    The gem to test

  • gem_line (String) —

    The line to update in the Gemfile



670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
 
# File 'lib/pdksync/utils.rb', line 670

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) ⇒ Object

Parameters:

  • gem_to_test (String) —

    The gem to test

  • gem_version_replacer (String) —

    The version to update in the Gemfile



754
755
756
757
758
759
760
761
 
# File 'lib/pdksync/utils.rb', line 754

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) ⇒ Object

Parameters:

  • client (PdkSync::GitPlatformClient) —

    The Git platform client used to get a repository.

  • module_names (Array) —

    String array of the names of Git platform repos



407
408
409
410
411
412
413
 
# File 'lib/pdksync/utils.rb', line 407

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) ⇒ Object

Parameters:

  • module_path —

    Path to the root dir of the module

  • metadata_json —

    Metadata in JSON format to write to the module root dir



1125
1126
1127
1128
1129
 
# File 'lib/pdksync/utils.rb', line 1125

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) ⇒ Object

write test report to file



897
898
899
900
901
 
# File 'lib/pdksync/utils.rb', line 897

def self.write_to_file(file, _data)
  File.open(file, 'a') do |f|
    f.write @data
  end
end