2 * Copyright (C) 2016-2020 Michael Jeanson <mjeanson@efficios.com>
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 import hudson.AbortException
20 import hudson.console.HyperlinkNote
21 import java.util.concurrent.CancellationException
22 import org.eclipse.jgit.api.Git
23 import org.eclipse.jgit.lib.Ref
26 class InvalidKVersionException extends Exception {
27 public InvalidKVersionException(String message) {
32 class EmptyKVersionException extends Exception {
33 public EmptyKVersionException(String message) {
38 class VanillaKVersion implements Comparable<VanillaKVersion> {
44 Integer rc = Integer.MAX_VALUE
48 VanillaKVersion(version) {
52 static VanillaKVersion minKVersion() {
53 return new VanillaKVersion("v0.0.0")
56 static VanillaKVersion maxKVersion() {
57 return new VanillaKVersion("v" + Integer.MAX_VALUE + ".0.0")
60 static VanillaKVersion factory(version) {
61 return new VanillaKVersion(version)
69 this.rc = Integer.MAX_VALUE
72 throw new EmptyKVersionException("Empty kernel version")
75 def match = version =~ /^v(\d+)\.(\d+)(\.(\d+))?(\.(\d+))?(-rc(\d+))?$/
77 throw new InvalidKVersionException("Invalid kernel version: ${version}")
83 this.major = Integer.parseInt(match.group(1))
84 if (this.major <= 2) {
86 this.majorB = Integer.parseInt(match.group(2))
90 if (match.group(2 + offset) != null) {
91 this.minor = Integer.parseInt(match.group(2 + offset))
95 if (match.group(4 + offset) != null) {
96 this.patch = Integer.parseInt(match.group(4 + offset))
100 if (match.group(8) != null) {
101 this.rc = Integer.parseInt(match.group(8))
105 // Return true if this version is a release candidate
107 return this.rc != Integer.MAX_VALUE
110 // Return true if both version are of the same stable branch
111 Boolean isSameStable(VanillaKVersion o) {
112 if (this.major != o.major) {
115 if (this.majorB != o.majorB) {
118 if (this.minor != o.minor) {
125 @Override int compareTo(VanillaKVersion o) {
126 if (this.major != o.major) {
127 return Integer.compare(this.major, o.major)
129 if (this.majorB != o.majorB) {
130 return Integer.compare(this.majorB, o.majorB)
132 if (this.minor != o.minor) {
133 return Integer.compare(this.minor, o.minor)
135 if (this.patch != o.patch) {
136 return Integer.compare(this.patch, o.patch)
138 if (this.rc != o.rc) {
139 return Integer.compare(this.rc, o.rc)
147 String vString = "v${this.major}"
149 if (this.majorB > 0) {
150 vString = vString.concat(".${this.majorB}")
153 vString = vString.concat(".${this.minor}")
155 if (this.patch > 0) {
156 vString = vString.concat(".${this.patch}")
159 if (this.rc > 0 && this.rc < Integer.MAX_VALUE) {
160 vString = vString.concat("-rc${this.rc}")
166 class UbuntuKVersion implements Comparable<UbuntuKVersion> {
175 Boolean isLTS = false
179 UbuntuKVersion(version) {
183 static UbuntuKVersion minKVersion() {
184 return new UbuntuKVersion("Ubuntu-lts-0.0.0-0.0")
187 static UbuntuKVersion maxKVersion() {
188 return new UbuntuKVersion("Ubuntu-" + Integer.MAX_VALUE + ".0.0-0.0")
191 static UbuntuKVersion factory(version) {
192 return new UbuntuKVersion(version)
205 throw new EmptyKVersionException("Empty kernel version")
208 //'Ubuntu-hwe-5.8-5.8.0-19.20_20.04.3',
209 //'Ubuntu-lts-4.8.0-27.29_16.04.1',
210 //'Ubuntu-4.4.0-70.91',
211 def match = version =~ /^Ubuntu-(lts-|hwe-)??(?:\d+\.\d+-)??(\d+)\.(\d+)\.(\d+)-(\d+)\.(\d+)(.*)??$/
213 throw new InvalidKVersionException("Invalid kernel version: ${version}")
216 if (match.group(1) != null) {
218 this.strLTS = match.group(1)
222 this.major = Integer.parseInt(match.group(2))
225 this.minor = Integer.parseInt(match.group(3))
228 this.patch = Integer.parseInt(match.group(4))
231 this.umajor = Integer.parseInt(match.group(5))
234 this.uminor = Integer.parseInt(match.group(6))
236 if (match.group(7) != null) {
237 this.suffix = match.group(7)
241 // Return true if this version is a release candidate
246 // Return true if both version are of the same stable branch
247 Boolean isSameStable(UbuntuKVersion o) {
248 if (this.isLTS != o.isLTS) {
251 if (this.major != o.major) {
254 if (this.minor != o.minor) {
257 if (this.patch != o.patch) {
264 @Override int compareTo(UbuntuKVersion o) {
265 if (this.major != o.major) {
266 return Integer.compare(this.major, o.major)
268 if (this.minor != o.minor) {
269 return Integer.compare(this.minor, o.minor)
271 if (this.patch != o.patch) {
272 return Integer.compare(this.patch, o.patch)
274 if (this.umajor != o.umajor) {
275 return Integer.compare(this.umajor, o.umajor)
277 if (this.uminor != o.uminor) {
278 return Integer.compare(this.uminor, o.uminor)
280 if (this.isLTS != o.isLTS) {
293 String vString = "Ubuntu-"
296 vString = vString.concat("${this.strLTS}")
299 // The tag pattern changed for HWE kernels >= 5.0
300 if (this.isLTS && this.major >= 5) {
301 vString = vString.concat("${this.major}.${this.minor}-${this.major}.${this.minor}.${this.patch}-${this.umajor}.${this.uminor}${this.suffix}")
303 vString = vString.concat("${this.major}.${this.minor}.${this.patch}-${this.umajor}.${this.uminor}${this.suffix}")
311 // Retrieve parameters of the current build
312 def mbranch = build.getEnvironment(listener).get('GIT_BRANCH').minus('origin/')
313 def maxConcurrentBuild = build.buildVariableResolver.resolve('maxConcurrentBuild')
314 def kgitrepo = build.buildVariableResolver.resolve('kgitrepo')
315 def kverfloor_raw = build.buildVariableResolver.resolve('kverfloor')
316 def kverceil_raw = build.buildVariableResolver.resolve('kverceil')
317 def kverfilter = build.buildVariableResolver.resolve('kverfilter')
318 def kverrc = build.buildVariableResolver.resolve('kverrc')
319 def uversion = build.buildVariableResolver.resolve('uversion')
320 def job = Hudson.instance.getJob(build.buildVariableResolver.resolve('kbuildjob'))
321 def currentJobName = build.project.getFullDisplayName()
322 def gitmodpath = build.getEnvironment(listener).get('WORKSPACE') + "/src/lttng-modules"
324 // Get the out variable
325 def config = new HashMap()
326 def bindings = getBinding()
327 config.putAll(bindings.getVariables())
328 def out = config['out']
331 // Get the lttng-modules git url
332 def gitmodrepo = Git.open(new File(gitmodpath))
333 def mgitrepo = gitmodrepo.getRepository().getConfig().getString("remote", "origin", "url")
335 // Get tags from git repository
336 def refs = Git.lsRemoteRepository().setTags(true).setRemote(kgitrepo).call()
338 // Get kernel versions to build
343 def kversionFactory = ""
345 if (uversion != null) {
346 kversionFactory = new UbuntuKVersion()
350 ~/^refs\/tags\/(Ubuntu-5\.15\.0-\d{1,3}?\.[\d]+)$/,
351 ~/^refs\/tags\/(Ubuntu-hwe-6\.2-6\.2\.0-.*_22\.04\.\d+)$/,
357 ~/^refs\/tags\/(Ubuntu-5\.4\.0-\d{1,3}?\.[\d]+)$/,
358 ~/^refs\/tags\/(Ubuntu-hwe-5\.13-5\.13\.0-.*_20\.04\.\d+)$/,
364 ~/^refs\/tags\/(Ubuntu-4\.15\.0-\d{1,3}?\.[\d]+)$/,
365 ~/^refs\/tags\/(Ubuntu-hwe-5\.4-5\.4\.0-.*_18\.04\.\d+)$/,
371 ~/^refs\/tags\/(Ubuntu-4\.4\.0-\d{1,3}?\.[\d]+)$/,
372 ~/^refs\/tags\/(Ubuntu-hwe-4\.15\.0-.*_16\.04\.\d+)$/,
377 println "Unsupported Ubuntu version: ${uversion}"
378 throw new InterruptedException()
383 kversionFactory = new VanillaKVersion()
385 ~/^refs\/tags\/(v[\d\.]+(-rc(\d+))?)$/,
392 // Parse kernel versions
395 kverfloor = kversionFactory.factory(kverfloor_raw)
396 } catch (EmptyKVersionException e) {
397 kverfloor = kversionFactory.minKVersion()
402 kverceil = kversionFactory.factory(kverceil_raw)
403 } catch (EmptyKVersionException e) {
404 kverceil = kversionFactory.maxKVersion()
407 // Build a sorted list of versions to build
409 for (matchStr in matchStrs) {
410 def match = ref.getName() =~ matchStr
411 if (match && !blacklist.contains(match.group(1))) {
412 def v = kversionFactory.factory(match.group(1))
414 if ((v >= kverfloor) && (v < kverceil)) {
425 // The filtering step assumes the version lists are sorted
429 switch (kverfilter) {
431 // Keep only the head of each stable branch
432 println('Filter kernel versions to keep only the latest point release of each stable branch.')
434 for (i = 0; i < kversions.size(); i++) {
435 def curr = kversions[i]
436 def next = i < kversions.size() - 1 ? kversions[i + 1] : null
439 if (curr.isSameStable(next)) {
448 // Keep only the head of each LTS branch and the latest non-RC tag
449 println('Filter kernel versions to keep only the latest point release of each lts branch and the current stable.')
451 def lts_kversions = []
452 lts_kversions.add(kversionFactory.factory("v4.4")) // SLTS until 2026
453 lts_kversions.add(kversionFactory.factory("v4.9")) // LTS until January 2023
454 lts_kversions.add(kversionFactory.factory("v4.14")) // LTS until January 2024
455 lts_kversions.add(kversionFactory.factory("v4.19")) // LTS until December 2024
456 lts_kversions.add(kversionFactory.factory("v5.4")) // LTS until December 2025
457 lts_kversions.add(kversionFactory.factory("v5.10")) // LTS until December 2026
458 lts_kversions.add(kversionFactory.factory("v5.15")) // LTS until October 2026
459 lts_kversions.add(kversionFactory.factory("v6.1")) // LTS until December 2026
461 // First filter the head of each branch
462 for (i = 0; i < kversions.size(); i++) {
463 def curr = kversions[i]
464 def next = i < kversions.size() - 1 ? kversions[i + 1] : null
467 if (curr.isSameStable(next)) {
474 for (i = 0; i < kversions.size(); i++) {
475 def curr = kversions[i]
477 // Keep the newest tag
478 if (i == kversions.size() - 1) {
482 // Prune non-LTS versions
484 for (j = 0; j < lts_kversions.size(); j++) {
485 if (curr.isSameStable(lts_kversions[j])) {
499 // No filtering of kernel versions
500 println('No kernel versions filtering selected.')
504 if (kverrc == "true") {
505 // If the last RC version is newer than the last stable, add it to the build list
506 if (kversionsRC.size() > 0 && kversionsRC.last() > kversions.last()) {
507 kversions.add(kversionsRC.last())
511 println "Building the following kernel versions:"
512 for (k in kversions) {
516 // Debug: Stop build here
517 //throw new InterruptedException()
519 def joburl = HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
522 def ongoingBuild = []
525 def similarJobQueued = 0;
527 // Loop while we have kernel versions remaining or jobs running
528 while ( kversions.size() != 0 || ongoingBuild.size() != 0 ) {
530 if(ongoingBuild.size() < maxConcurrentBuild.toInteger() && kversions.size() != 0) {
531 def kversion = kversions.pop()
533 new StringParameterValue('mversion', mbranch),
534 new StringParameterValue('mgitrepo', mgitrepo),
535 new StringParameterValue('ktag', kversion.toString()),
536 new StringParameterValue('kgitrepo', kgitrepo),
539 // Launch the parametrized build
540 def param_build = job.scheduleBuild2(0, new Cause.UpstreamCause(build), new ParametersAction(job_params))
541 println "triggering ${joburl} for the ${mbranch} branch on kernel ${kversion}"
543 // Add it to the ongoing build queue
544 ongoingBuild.push(param_build)
548 println "Waiting... Queued: " + kversions.size() + " Running: " + ongoingBuild.size()
552 if (e in InterruptedException) {
553 build.setResult(hudson.model.Result.ABORTED)
554 throw new InterruptedException()
560 // Abort job if a newer instance is queued
561 if (!currentJobName.contains("gerrit")) {
562 similarJobQueued = Hudson.instance.queue.items.count{it.task.getFullDisplayName() == currentJobName}
563 if (similarJobQueued > 0) {
564 println "Abort, a newer instance of the job was queued"
565 build.setResult(hudson.model.Result.ABORTED)
566 throw new InterruptedException()
570 def i = ongoingBuild.iterator()
571 while ( i.hasNext() ) {
572 currentBuild = i.next()
573 if ( currentBuild.isCancelled() || currentBuild.isDone() ) {
578 def matrixParent = currentBuild.get()
579 allBuilds.add(matrixParent)
580 def kernelStr = matrixParent.buildVariableResolver.resolve("ktag")
581 println "${matrixParent.fullDisplayName} (${kernelStr}) completed with status ${matrixParent.result}"
583 // Process child runs of matrixBuild
584 def childRuns = matrixParent.getRuns()
585 for ( childRun in childRuns ) {
586 println "\t${childRun.fullDisplayName} (${kernelStr}) completed with status ${childRun.result}"
587 if (childRun.result != Result.SUCCESS) {
588 failedRuns.add(childRun)
597 // Get log of failed runs
598 for (failedRun in failedRuns) {
599 println "---START---"
600 failedRun.writeWholeLogTo(out)
604 println "---Build report---"
605 for (b in allBuilds) {
606 def kernelStr = b.buildVariableResolver.resolve("ktag")
607 println "${b.fullDisplayName} (${kernelStr}) completed with status ${b.result}"
614 // Mark this build failed if any child build has failed
616 build.setResult(hudson.model.Result.FAILURE)