module PdkSync::Utils
Constants
- NAME
- OPERATINGSYSTEM
- OPERATINGSYSTEMRELEASE
- OPERATINGSYSTEM_SUPPORT
- REQUIREMENTS
Public Class Methods
@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
@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
@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
@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
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
# 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
@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
@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
@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
@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
@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
@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
@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
@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
# File lib/pdksync/utils.rb, line 16 def self.configuration @configuration ||= PdkSync::Configuration.new end
@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
@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
@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
@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
@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
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
@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
@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 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
@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
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
@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
@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
@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
@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
@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
@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
@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
@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
# 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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@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
# 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
# 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
@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
@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
@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
@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
@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
@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
@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
@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
@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 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