| /** |
| * |
| * @param projectUrl the github project url |
| */ |
| def getProject(String projectUrl) { |
| return (projectUrl =~ /((git|ssh|http(s)?)|(git@[\w\.]+))(:(\/\/)?(github.com\/))([\w\.@\:\/\-~]+)(\.git)(\/)?/)[0][8] |
| } |
| |
| /** |
| * |
| * @param projectUrl the github project url |
| */ |
| def getGroup(String projectUrl) { |
| return getProjectGroupName(getProject(projectUrl))[0] |
| } |
| |
| /** |
| * Returns an array containing group and name |
| * |
| * @param project the project |
| * @param defaultGroup the default project group. Optional. |
| */ |
| def getProjectGroupName(String project, String defaultGroup = "apache") { |
| def projectNameGroup = project.split("\\/") |
| def group = projectNameGroup.size() > 1 ? projectNameGroup[0] : defaultGroup |
| def name = projectNameGroup.size() > 1 ? projectNameGroup[1] : project |
| return [group, name] |
| } |
| |
| /** |
| * Returns the path to the project dir |
| * @param projectGroupName |
| * @return |
| */ |
| def getProjectDirPath(String project, String defaultGroup = "apache") { |
| def projectGroupName = getProjectGroupName(project, defaultGroup) |
| return "${env.WORKSPACE}/${projectGroupName[0]}_${projectGroupName[1]}" |
| } |
| |
| /** |
| * |
| * Stores git information into an env variable to be retrievable at any point of the pipeline |
| * |
| * @param projectName to store commit |
| */ |
| def storeGitInformation(String projectName) { |
| def gitInformationReport = env.GIT_INFORMATION_REPORT ? "${env.GIT_INFORMATION_REPORT}; " : "" |
| gitInformationReport += "${projectName}=${githubscm.getCommit().replace(';', '').replace('=', '')} Branch [${githubscm.getBranch().replace(';', '').replace('=', '')}] Remote [${githubscm.getRemoteInfo('origin', 'url').replace(';', '').replace('=', '')}]" |
| env.GIT_INFORMATION_REPORT = gitInformationReport |
| |
| def gitHashes = env.GIT_INFORMATION_HASHES ? "${env.GIT_INFORMATION_HASHES};" : "" |
| gitHashes += "${projectName}=${githubscm.getCommitHash()}" |
| env.GIT_INFORMATION_HASHES = gitHashes |
| } |
| |
| /** |
| * |
| * prints GIT_INFORMATION_REPORT variable |
| */ |
| def printGitInformationReport() { |
| if (env.GIT_INFORMATION_REPORT?.trim()) { |
| def result = env.GIT_INFORMATION_REPORT.split(';').inject([:]) { map, token -> |
| token.split('=').with { key, value -> |
| map[key.trim()] = value.trim() |
| } |
| map |
| } |
| def report = ''' |
| ------------------------------------------ |
| GIT INFORMATION REPORT |
| ------------------------------------------ |
| ''' |
| result.each { key, value -> |
| report += "${key}: ${value}\n" |
| } |
| println report |
| } else { |
| println '[WARNING] The variable GIT_INFORMATION_REPORT does not exist' |
| } |
| } |
| |
| /* |
| * Get the next major/minor/micro version, with a specific suffix if needed. |
| * The version string needs to be in the form X.Y.Z |
| */ |
| |
| def getNextVersion(String version, String type, String suffix = 'SNAPSHOT', boolean resetSubVersions = true) { |
| assert ['major', 'minor', 'micro'].contains(type) |
| Integer[] versionSplit = parseVersion(version) |
| if (versionSplit != null) { |
| int majorVersion = versionSplit[0] + (type == 'major' ? 1 : 0) |
| int minorVersion = resetSubVersions && type == 'major' ? 0 : (versionSplit[1] + (type == 'minor' ? 1 : 0)) |
| int microVersion = resetSubVersions && (type == 'major' || type == 'minor') ? 0 : (versionSplit[2] + (type == 'micro' ? 1 : 0)) |
| return "${majorVersion}.${minorVersion}.${microVersion}${suffix ? '-' + suffix : ''}" |
| } else { |
| return null |
| } |
| } |
| |
| String getMajorMinorVersion(String version) { |
| try { |
| String[] versionSplit = version.split("\\.") |
| return "${versionSplit[0]}.${versionSplit[1]}" |
| } catch (err) { |
| println "[ERROR] ${version} cannot be reduced to Major.minor" |
| throw err |
| } |
| } |
| |
| /* |
| * It parses a version string, which needs to be in the format X.Y.Z or X.Y.Z.suffix and returns the 3 numbers |
| * in an array. The optional suffix must not be numeric. |
| * <p> |
| * Valid version examples: |
| * 1.0.0 |
| * 1.0.0.Final |
| */ |
| |
| Integer[] parseVersion(String version) { |
| String[] versionSplit = version.split("\\.") |
| boolean hasNonNumericSuffix = versionSplit.length == 4 && !(versionSplit[3].isNumber()) |
| if (versionSplit.length == 3 || hasNonNumericSuffix) { |
| if (versionSplit[0].isNumber() && versionSplit[1].isNumber() && versionSplit[2].isNumber()) { |
| Integer[] vs = new Integer[3] |
| vs[0] = Integer.parseInt(versionSplit[0]) |
| vs[1] = Integer.parseInt(versionSplit[1]) |
| vs[2] = Integer.parseInt(versionSplit[2]) |
| return vs |
| } else { |
| error "Version ${version} is not in the required format. The major, minor, and micro parts should contain only numeric characters." |
| } |
| } else { |
| error "Version ${version} is not in the required format X.Y.Z or X.Y.Z.suffix." |
| } |
| } |
| |
| String getReleaseBranchFromVersion(String version) { |
| Integer[] versionSplit = parseVersion(version) |
| return "${versionSplit[0]}.${versionSplit[1]}.x" |
| } |
| |
| String calculateTargetReleaseBranch(String currentReleaseBranch, int addToMajor = 0, int addToMinor = 0) { |
| String targetBranch = currentReleaseBranch |
| String [] versionSplit = targetBranch.split("\\.") |
| if (versionSplit.length == 3 |
| && versionSplit[0].isNumber() |
| && versionSplit[1].isNumber() |
| && (versionSplit[2] == 'x' || versionSplit[2] == 'x-prod')) { |
| Integer newMajor = Integer.parseInt(versionSplit[0]) + addToMajor |
| Integer newMinor = Integer.parseInt(versionSplit[1]) + addToMinor |
| targetBranch = "${newMajor}.${newMinor}.${versionSplit[2]}" |
| } else { |
| println "Cannot parse targetBranch as release branch so going further with current value: ${targetBranch}" |
| } |
| return targetBranch |
| } |
| |
| /** |
| * It prepares the environment to avoid problems with plugins. For example files from SCM pipeline are deleted during checkout |
| */ |
| def prepareEnvironment() { |
| println """ |
| [INFO] Preparing Environment |
| [INFO] Copying WORKSPACE content env folder |
| """ |
| def envFolderName = '.ci-env' |
| if (fileExists("${env.WORKSPACE}/${envFolderName}")) { |
| println "[WARNING] folder ${env.WORKSPACE}/${envFolderName} already exist, won't create env folder again." |
| } else { |
| dir(env.WORKSPACE) { |
| sh "mkdir ${envFolderName}" |
| sh "cp -r `ls -A | grep -v '${envFolderName}'` ${envFolderName}/" |
| } |
| } |
| } |
| |
| /* |
| * Generate a hash composed of alphanumeric characters (lowercase) of a given size |
| */ |
| |
| String generateHash(int size) { |
| String alphabet = (('a'..'z') + ('0'..'9')).join("") |
| def random = new Random() |
| return (1..size).collect { alphabet[random.nextInt(alphabet.length())] }.join("") |
| } |
| |
| String generateTempFile() { |
| return sh(returnStdout: true, script: 'mktemp').trim() |
| } |
| |
| String generateTempFolder() { |
| return sh(returnStdout: true, script: 'mktemp -d').trim() |
| } |
| |
| void executeWithCredentialsMap(Map credentials, Closure closure) { |
| if (credentials.token) { |
| withCredentials([string(credentialsId: credentials.token, variable: 'QUAY_TOKEN')]) { |
| closure() |
| } |
| } else if (credentials.usernamePassword) { |
| withCredentials([usernamePassword(credentialsId: credentials.usernamePassword, usernameVariable: 'QUAY_USER', passwordVariable: 'QUAY_TOKEN')]) { |
| closure() |
| } |
| } else { |
| error 'No credentials given to execute the given closure' |
| } |
| } |
| |
| void cleanNode(String containerEngine = '') { |
| println '[INFO] Clean workspace' |
| cleanWs(disableDeferredWipeout: true) |
| println '[INFO] Workspace cleaned' |
| println '[INFO] Cleanup Maven artifacts' |
| maven.cleanRepository() |
| println '[INFO] .m2/repository cleaned' |
| if (containerEngine) { |
| println "[INFO] Cleanup ${containerEngine} containers/images" |
| cloud.cleanContainersAndImages(containerEngine) |
| } |
| } |
| |
| def spaceLeft() { |
| dir(env.WORKSPACE) { |
| println '[INFO] space left on the machine' |
| sh 'df -h' |
| println '[INFO] space of /home/jenkins' |
| sh "du -h -d1 /home/jenkins" |
| println '[INFO] space of workspace' |
| sh "du -h -d3 /home/jenkins/workspace" |
| } |
| } |
| |
| def replaceInAllFilesRecursive(String findPattern, String oldValueSedPattern, String newSedValue) { |
| sh "find . -name '${findPattern}' -type f -exec sed -i 's/${oldValueSedPattern}/${newSedValue}/g' {} \\;" |
| } |
| |
| /* |
| * Removes any partial downloaded dependencies from .m2 if the previous run was interrupted and no post actions were |
| * executed (cleanRepository()) and a new build is executed on the same machine |
| */ |
| def rmPartialDeps(){ |
| dir("${env.WORKSPACE}/.m2") { |
| sh "find . -regex \".*\\.part\\(\\.lock\\)?\" -exec rm -rf {} \\;" |
| } |
| } |
| |
| String retrieveConsoleLog(int numberOfLines = 100, String buildUrl = "${BUILD_URL}") { |
| return sh(returnStdout: true, script: "wget --no-check-certificate -qO - ${buildUrl}consoleText | tail -n ${numberOfLines}") |
| } |
| |
| String archiveConsoleLog(String id = '', int numberOfLines = 100, String buildUrl = "${BUILD_URL}") { |
| String filename = "${id ? "${id}_" : ''}console.log" |
| sh "rm -rf ${filename}" |
| writeFile(text: retrieveConsoleLog(numberOfLines, buildUrl), file: filename) |
| archiveArtifacts(artifacts: filename) |
| } |
| |
| def retrieveTestResults(String buildUrl = "${BUILD_URL}") { |
| return readJSON(text: sh(returnStdout: true, script: "wget --no-check-certificate -qO - ${buildUrl}testReport/api/json?depth=1")) |
| } |
| |
| def retrieveFailedTests(String buildUrl = "${BUILD_URL}") { |
| def testResults = retrieveTestResults(buildUrl) |
| |
| def allCases = [] |
| testResults.suites?.each { testSuite -> |
| allCases.addAll(testSuite.cases) |
| } |
| |
| def failedTests = [] |
| testResults.suites?.each { testSuite -> |
| testSuite.cases?.each { testCase -> |
| if (!['PASSED', 'SKIPPED', 'FIXED'].contains(testCase.status)) { |
| def failedTest = [:] |
| |
| boolean hasSameNameCases = allCases.findAll { it.name == testCase.name && it.className == testCase.className }.size() > 1 |
| |
| failedTest.status = testCase.status |
| |
| // Retrieve class name |
| fullClassName = testCase.className |
| int lastIndexOf = fullClassName.lastIndexOf('.') |
| packageName = fullClassName.substring(0, lastIndexOf) |
| className = fullClassName.substring(lastIndexOf + 1) |
| |
| failedTest.name = testCase.name |
| failedTest.packageName = packageName |
| failedTest.className = className |
| failedTest.enclosingBlockNames = testSuite.enclosingBlockNames?.reverse()?.join(' / ') |
| |
| failedTest.fullName = "${packageName}.${className}.${failedTest.name}" |
| // If other cases have the same className / name, Jenkins uses the enclosingBlockNames for the URL distinction |
| if (hasSameNameCases && testSuite.enclosingBlockNames) { |
| failedTest.fullName = "${testSuite.enclosingBlockNames.reverse().join(' / ')} / ${failedTest.fullName}" |
| } |
| |
| // Construct test url |
| String urlLeaf = '' |
| // If other cases have the same className / name, Jenkins uses the enclosingBlockNames for the URL distinction |
| if (hasSameNameCases && testSuite.enclosingBlockNames) { |
| urlLeaf += testSuite.enclosingBlockNames.reverse().join('___') |
| } |
| urlLeaf += urlLeaf ? '___' : urlLeaf |
| urlLeaf += "${failedTest.name == "(?)" ? "___" : failedTest.name}/" |
| urlLeaf = urlLeaf.replaceAll(' ', '_') |
| .replaceAll('&', '_') |
| .replaceAll('-', '_') |
| failedTest.url = "${buildUrl}testReport/${packageName}/${className}/${urlLeaf}" |
| |
| failedTest.details = [null, 'null'].contains(testCase.errorDetails) ? '' : testCase.errorDetails |
| failedTest.stacktrace = [null, 'null'].contains(testCase.errorStackTrace) ? '' : testCase.errorStackTrace |
| failedTests.add(failedTest) |
| } |
| } |
| } |
| |
| return failedTests |
| } |
| |
| String retrieveArtifact(String artifactPath, String buildUrl = "${BUILD_URL}") { |
| String finalUrl = "${buildUrl}artifact/${artifactPath}" |
| String httpCode = sh(returnStdout: true, script: "curl -o /dev/null --silent -Iw '%{http_code}' ${finalUrl}") |
| return httpCode == "200" ? sh(returnStdout: true, script: "wget --no-check-certificate -qO - ${finalUrl}") : '' |
| } |
| |
| def retrieveJobInformation(String buildUrl = "${BUILD_URL}") { |
| return readJSON(text: sh(returnStdout: true, script: "wget --no-check-certificate -qO - ${buildUrl}api/json?depth=0")) |
| } |
| |
| boolean isJobResultSuccess(String jobResult) { |
| return jobResult == 'SUCCESS' |
| } |
| |
| boolean isJobResultFailure(String jobResult) { |
| return jobResult == 'FAILURE' |
| } |
| |
| boolean isJobResultAborted(String jobResult) { |
| return jobResult == 'ABORTED' |
| } |
| |
| boolean isJobResultUnstable(String jobResult) { |
| return jobResult == 'UNSTABLE' |
| } |
| |
| /* |
| * Return the build/test summary of a job |
| * |
| * outputStyle possibilities: 'ZULIP' (default), 'GITHUB' |
| */ |
| String getMarkdownTestSummary(String jobId = '', String additionalInfo = '', String buildUrl = "${BUILD_URL}", String outputStyle = 'ZULIP') { |
| def jobInfo = retrieveJobInformation(buildUrl) |
| |
| // Check if any *_console.log is available as artifact first |
| String defaultConsoleLogId = 'Console Logs' |
| Map consoleLogs = jobInfo.artifacts?.collect { it.fileName } |
| .findAll { it.endsWith('console.log') } |
| .collectEntries { filename -> |
| int index = filename.lastIndexOf('_') |
| String logId = index > 0 ? filename.substring(0, index) : defaultConsoleLogId |
| return [ (logId) : retrieveArtifact(filename, buildUrl) ] |
| } ?: [ (defaultConsoleLogId) : retrieveConsoleLog(50, buildUrl)] |
| |
| String jobResult = jobInfo.result |
| String summary = """ |
| ${jobId ? "**${jobId} job**" : 'Job'} ${formatBuildNumber(outputStyle, BUILD_NUMBER)} was: **${jobResult}** |
| """ |
| |
| if (!isJobResultSuccess(jobResult)) { |
| summary += "Possible explanation: ${getResultExplanationMessage(jobResult)}\n" |
| } |
| |
| if (additionalInfo) { |
| summary += """ |
| ${additionalInfo} |
| """ |
| } |
| |
| if (!isJobResultSuccess(jobResult)) { |
| boolean testResultsFound = false |
| summary += "\nPlease look here: ${buildUrl}display/redirect" |
| |
| try { |
| def testResults = retrieveTestResults(buildUrl) |
| def failedTests = retrieveFailedTests(buildUrl) |
| testResultsFound=true |
| |
| summary += """ |
| \n**Test results:** |
| - PASSED: ${testResults.passCount} |
| - FAILED: ${testResults.failCount} |
| """ |
| |
| summary += 'GITHUB'.equalsIgnoreCase(outputStyle) ? """ |
| Those are the test failures: ${failedTests.size() <= 0 ? 'none' : '\n'}${failedTests.collect { failedTest -> |
| return """<details> |
| <summary><a href="${failedTest.url}">${failedTest.fullName}</a></summary> |
| ${formatTextForHtmlDisplay(failedTest.details ?: failedTest.stacktrace)} |
| </details>""" |
| }.join('\n')} |
| """ |
| : """ |
| Those are the test failures: ${failedTests.size() <= 0 ? 'none' : '\n'}${failedTests.collect { failedTest -> |
| return """```spoiler [${failedTest.fullName}](${failedTest.url}) |
| ${failedTest.details ?: failedTest.stacktrace} |
| ```""" |
| }.join('\n')} |
| """ |
| } catch (err) { |
| echo 'No test results found' |
| } |
| |
| // Display console logs if no test results found |
| if (!(jobResult == 'UNSTABLE' && testResultsFound)) { |
| summary += 'GITHUB'.equalsIgnoreCase(outputStyle) ? """ |
| See console log: |
| ${consoleLogs.collect { key, value -> |
| return """<details> |
| <summary><b>${key}</b></summary> |
| ${formatTextForHtmlDisplay(value)} |
| </details> |
| """ |
| }.join('')}""" |
| : """ |
| See console log: |
| ${consoleLogs.collect { key, value -> |
| return """```spoiler ${key} |
| ${value} |
| ``` |
| """ |
| }.join('')}""" |
| } |
| } |
| |
| return summary |
| } |
| |
| String getResultExplanationMessage(String jobResult) { |
| switch (jobResult) { |
| case 'SUCCESS': |
| return 'Do I need to explain ?' |
| case 'UNSTABLE': |
| return 'This should be test failures' |
| case 'FAILURE': |
| return 'Pipeline failure or project build failure' |
| case 'ABORTED': |
| return 'Most probably a timeout, please review' |
| default: |
| return 'Woops ... I don\'t know about this result value ... Please ask maintainer.' |
| } |
| } |
| |
| String formatTextForHtmlDisplay(String text) { |
| return text.replaceAll('\n', '<br/>') |
| } |
| |
| String formatBuildNumber(String outputStyle, String buildNumber) { |
| return 'GITHUB'.equalsIgnoreCase(outputStyle) ? "`#${buildNumber}`" : "#${buildNumber}" |
| } |
| |
| /** |
| * Encode the provided string value in the provided encoding |
| * @param value string to encode |
| * @param encoding [default UTF-8] |
| * @return the encoded string |
| */ |
| String encode(String value, String encoding='UTF-8') { |
| return URLEncoder.encode(value, encoding) |
| } |
| |
| /** |
| * Serialize the parameters converting a Map into an URL query string, like: |
| * {A: 1, B: 2} --> 'A=1&B=2' |
| * @param params key-value map representation of the parameters |
| * @return URL query string |
| */ |
| String serializeQueryParams(Map params) { |
| return params.collect { "${it.getKey()}=${encode(it.getValue() as String)}" }.join('&') |
| } |
| |
| /** |
| * Execute the provided closure within Kerberos authentication context |
| * @param keytabId id of the keytab to be used |
| * @param closure code to run in the kerberos auth context |
| * @param domain kerberos domain to look for into the keytab |
| * @param retry number of max retries to perform if kinit fails |
| */ |
| def withKerberos(String keytabId, Closure closure, String domain = 'REDHAT.COM', int nRetries = 5) { |
| withCredentials([file(credentialsId: keytabId, variable: 'KEYTAB_FILE')]) { |
| env.KERBEROS_PRINCIPAL = sh(returnStdout: true, script: "klist -kt $KEYTAB_FILE |grep $domain | awk -F' ' 'NR==1{print \$4}' ").trim() |
| |
| if (!env.KERBEROS_PRINCIPAL?.trim()) { |
| throw new Exception("[ERROR] found blank KERBEROS_PRINCIPAL, kerberos authetication failed.") |
| } |
| |
| // check if kerberos authentication already exists with provided principal |
| def currentPrincipal = sh(returnStdout: true, script: "klist | grep -i 'Default principal' | awk -F':' 'NR==1{print \$2}' ").trim() |
| |
| if (currentPrincipal != env.KERBEROS_PRINCIPAL) { |
| def kerberosStatus = 0 |
| for (int i = 0; i < nRetries; i++) { |
| kerberosStatus = sh(returnStatus: true, script: "kinit ${env.KERBEROS_PRINCIPAL} -kt $KEYTAB_FILE") |
| if (kerberosStatus == 0) { |
| // exit at first success |
| break |
| } |
| } |
| |
| // if the kerberos status is still != 0 after nRetries throw exception |
| if (kerberosStatus != 0) { |
| throw new Exception("[ERROR] kinit failed with non-zero status.") |
| } |
| } else { |
| println "[INFO] ${env.KERBEROS_PRINCIPAL} already authenticated, skipping kinit." |
| } |
| |
| closure() |
| } |
| } |
| |
| def runWithPythonVirtualEnv(String cmd, String virtualEnvName, boolean returnStdout = false) { |
| return sh(returnStdout: returnStdout, script: """ |
| source ~/virtenvs/${virtualEnvName}/bin/activate |
| ${cmd} |
| """) |
| } |
| |
| int getJobDurationInSeconds() { |
| long startTimestamp = retrieveJobInformation().timestamp |
| long currentTimestamp = new Date().getTime() |
| return (int) ((currentTimestamp - startTimestamp) / 1000) |
| } |
| |
| String displayDurationFromSeconds(int durationInSec) { |
| String result = '' |
| int seconds = durationInSec |
| int minutes = durationInSec / 60 |
| if (minutes > 0) { |
| seconds = seconds - minutes * 60 |
| int hours = minutes / 60 |
| if (hours > 0) { |
| minutes = minutes - hours*60 |
| result += "${hours}h" |
| } |
| result += "${minutes}m" |
| } |
| result += "${seconds}s" |
| return result |
| } |
| |
| /** |
| * Method to wait for dockerd to be started. Put in initial pipeline stages to make sure all starts in time. |
| */ |
| void waitForDocker() { |
| sleep(10) // give it some ahead time not to invoke docker exec immediately after container start |
| sh 'wait-for-docker.sh' // script in kogito-ci-build image itself put in /usr/local/bin |
| } |
| |
| /** |
| * Method to wrap original label and exclude nodes that were marked as faulty in some of the parent folders. |
| * Example usage in agent block: `label util.avoidFaultyNodes('ubuntu')` |
| * `FAULTY_NODES` environment variable is inherited down the folder tree and available in jobs. |
| * @param label Node label to be used. If empty, 'ubuntu' will be used as default |
| * @return Node label extended with an expression ensuring to exclude nodes marked as faulty. |
| */ |
| String avoidFaultyNodes(String label = 'ubuntu') { |
| if (label.isEmpty()) { |
| label = 'ubuntu' |
| } |
| String faultyNodesString = env.FAULTY_NODES |
| if((faultyNodesString == null) || faultyNodesString.isEmpty()) { |
| return label |
| } |
| String[] faultyNodes = faultyNodesString.split(',') |
| String result = "(${label}) && !(${String.join(' || ', faultyNodes)})" |
| return result.toString() |
| } |
