scripts/lttng-modules/master.groovy

   1 /**
   2  * Copyright (C) 2016-2020 Michael Jeanson <mjeanson@efficios.com>
   3  *
   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.
   8  *
   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.
  13  *
  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/>.
  16  */
  17
  18 import hudson.model.*
  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
  24
  25
  26 class InvalidKVersionException extends Exception {
  27   public InvalidKVersionException(String message) {
  28     super(message)
  29   }
  30 }
  31
  32 class EmptyKVersionException extends Exception {
  33   public EmptyKVersionException(String message) {
  34     super(message)
  35   }
  36 }
  37
  38 class VanillaKVersion implements Comparable<VanillaKVersion> {
  39
  40   Integer major = 0
  41   Integer majorB = 0
  42   Integer minor = 0
  43   Integer patch = 0
  44   Integer rc = Integer.MAX_VALUE
  45
  46   VanillaKVersion() {}
  47
  48   VanillaKVersion(version) {
  49     this.parse(version)
  50   }
  51
  52   static VanillaKVersion minKVersion() {
  53     return new VanillaKVersion("v0.0.0")
  54   }
  55
  56   static VanillaKVersion maxKVersion() {
  57     return new VanillaKVersion("v" + Integer.MAX_VALUE + ".0.0")
  58   }
  59
  60   static VanillaKVersion factory(version) {
  61     return new VanillaKVersion(version)
  62   }
  63
  64   def parse(version) {
  65     this.major = 0
  66     this.majorB = 0
  67     this.minor = 0
  68     this.patch = 0
  69     this.rc = Integer.MAX_VALUE
  70
  71     if (!version) {
  72       throw new EmptyKVersionException("Empty kernel version")
  73     }
  74
  75     def match = version =~ /^v(\d+)\.(\d+)(\.(\d+))?(\.(\d+))?(-rc(\d+))?$/
  76     if (!match) {
  77       throw new InvalidKVersionException("Invalid kernel version: ${version}")
  78     }
  79
  80     Integer offset = 0;
  81
  82     // Major
  83     this.major = Integer.parseInt(match.group(1))
  84     if (this.major <= 2) {
  85       offset = 2
  86       this.majorB = Integer.parseInt(match.group(2))
  87     }
  88
  89     // Minor
  90     if (match.group(2 + offset) != null) {
  91       this.minor = Integer.parseInt(match.group(2 + offset))
  92     }
  93
  94     // Patch level
  95     if (match.group(4 + offset) != null) {
  96       this.patch = Integer.parseInt(match.group(4 + offset))
  97     }
  98
  99     // RC
 100     if (match.group(8) != null) {
 101       this.rc = Integer.parseInt(match.group(8))
 102     }
 103   }
 104
 105   // Return true if this version is a release candidate
 106   Boolean isRC() {
 107     return this.rc != Integer.MAX_VALUE
 108   }
 109
 110   // Return true if both version are of the same stable branch
 111   Boolean isSameStable(VanillaKVersion o) {
 112     if (this.major != o.major) {
 113       return false
 114     }
 115     if (this.majorB != o.majorB) {
 116       return false
 117     }
 118     if (this.minor != o.minor) {
 119       return false
 120     }
 121
 122     return true
 123   }
 124
 125   @Override int compareTo(VanillaKVersion o) {
 126     if (this.major != o.major) {
 127       return Integer.compare(this.major, o.major)
 128     }
 129     if (this.majorB != o.majorB) {
 130       return Integer.compare(this.majorB, o.majorB)
 131     }
 132     if (this.minor != o.minor) {
 133       return Integer.compare(this.minor, o.minor)
 134     }
 135     if (this.patch != o.patch) {
 136       return Integer.compare(this.patch, o.patch)
 137     }
 138     if (this.rc != o.rc) {
 139       return Integer.compare(this.rc, o.rc)
 140     }
 141
 142     // Same version
 143     return 0;
 144   }
 145
 146   String toString() {
 147     String vString = "v${this.major}"
 148
 149     if (this.majorB > 0) {
 150       vString = vString.concat(".${this.majorB}")
 151     }
 152
 153     vString = vString.concat(".${this.minor}")
 154
 155     if (this.patch > 0) {
 156       vString = vString.concat(".${this.patch}")
 157     }
 158
 159     if (this.rc > 0 && this.rc < Integer.MAX_VALUE) {
 160       vString = vString.concat("-rc${this.rc}")
 161     }
 162     return vString
 163   }
 164 }
 165
 166 class UbuntuKVersion implements Comparable<UbuntuKVersion> {
 167
 168   Integer major = 0
 169   Integer minor = 0
 170   Integer patch = 0
 171   Integer umajor = 0
 172   Integer uminor = 0
 173   String suffix = ""
 174   String strLTS = ""
 175   Boolean isLTS = false
 176
 177   UbuntuKVersion() {}
 178
 179   UbuntuKVersion(version) {
 180     this.parse(version)
 181   }
 182
 183   static UbuntuKVersion minKVersion() {
 184     return new UbuntuKVersion("Ubuntu-lts-0.0.0-0.0")
 185   }
 186
 187   static UbuntuKVersion maxKVersion() {
 188     return new UbuntuKVersion("Ubuntu-" + Integer.MAX_VALUE + ".0.0-0.0")
 189   }
 190
 191   static UbuntuKVersion factory(version) {
 192     return new UbuntuKVersion(version)
 193   }
 194
 195   def parse(version) {
 196     this.major = 0
 197     this.minor = 0
 198     this.patch = 0
 199     this.umajor = 0
 200     this.uminor = 0
 201     this.suffix = "";
 202     this.isLTS = false
 203
 204     if (!version) {
 205       throw new EmptyKVersionException("Empty kernel version")
 206     }
 207
 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+)(.*)??$/
 212     if (!match) {
 213       throw new InvalidKVersionException("Invalid kernel version: ${version}")
 214     }
 215
 216     if (match.group(1) != null) {
 217         this.isLTS = true
 218         this.strLTS = match.group(1)
 219     }
 220
 221     // Major
 222     this.major = Integer.parseInt(match.group(2))
 223
 224     // Minor
 225     this.minor = Integer.parseInt(match.group(3))
 226
 227     // Patch level
 228     this.patch = Integer.parseInt(match.group(4))
 229
 230     // Ubuntu major
 231     this.umajor = Integer.parseInt(match.group(5))
 232
 233     // Ubuntu minor
 234     this.uminor = Integer.parseInt(match.group(6))
 235
 236     if (match.group(7) != null) {
 237       this.suffix = match.group(7)
 238     }
 239   }
 240
 241   // Return true if this version is a release candidate
 242   Boolean isRC() {
 243     return false
 244   }
 245
 246   // Return true if both version are of the same stable branch
 247   Boolean isSameStable(UbuntuKVersion o) {
 248     if (this.isLTS != o.isLTS) {
 249       return false
 250     }
 251     if (this.major != o.major) {
 252       return false
 253     }
 254     if (this.minor != o.minor) {
 255       return false
 256     }
 257     if (this.patch != o.patch) {
 258       return false
 259     }
 260
 261     return true
 262   }
 263
 264   @Override int compareTo(UbuntuKVersion o) {
 265     if (this.major != o.major) {
 266       return Integer.compare(this.major, o.major)
 267     }
 268     if (this.minor != o.minor) {
 269       return Integer.compare(this.minor, o.minor)
 270     }
 271     if (this.patch != o.patch) {
 272       return Integer.compare(this.patch, o.patch)
 273     }
 274     if (this.umajor != o.umajor) {
 275       return Integer.compare(this.umajor, o.umajor)
 276     }
 277     if (this.uminor != o.uminor) {
 278       return Integer.compare(this.uminor, o.uminor)
 279     }
 280     if (this.isLTS != o.isLTS) {
 281       if (o.isLTS) {
 282         return 1
 283       } else {
 284         return -1
 285       }
 286     }
 287
 288     // Same version
 289     return 0;
 290   }
 291
 292   String toString() {
 293     String vString = "Ubuntu-"
 294
 295     if (this.isLTS) {
 296       vString = vString.concat("${this.strLTS}")
 297     }
 298
 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}")
 302     } else {
 303       vString = vString.concat("${this.major}.${this.minor}.${this.patch}-${this.umajor}.${this.uminor}${this.suffix}")
 304     }
 305
 306     return vString
 307   }
 308 }
 309
 310
 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"
 323
 324 // Get the out variable
 325 def config = new HashMap()
 326 def bindings = getBinding()
 327 config.putAll(bindings.getVariables())
 328 def out = config['out']
 329
 330
 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")
 334
 335 // Get tags from git repository
 336 def refs = Git.lsRemoteRepository().setTags(true).setRemote(kgitrepo).call()
 337
 338 // Get kernel versions to build
 339 def kversions = []
 340 def kversionsRC = []
 341 def matchStrs = []
 342 def blacklist = []
 343 def kversionFactory = ""
 344
 345 if (uversion != null) {
 346   kversionFactory = new UbuntuKVersion()
 347   switch (uversion) {
 348     case 'jammy':
 349       matchStrs = [
 350         ~/^refs\/tags\/(Ubuntu-5\.15\.0-\d{1,3}?\.[\d]+)$/,
 351         ~/^refs\/tags\/(Ubuntu-hwe-6\.2-6\.2\.0-.*_22\.04\.\d+)$/,
 352         ~/^refs\/tags\/(Ubuntu-hwe-6\.5-6\.5\.0-.*_22\.04\.\d+)$/,
 353       ]
 354       break
 355
 356     case 'focal':
 357       matchStrs = [
 358         ~/^refs\/tags\/(Ubuntu-5\.4\.0-\d{1,3}?\.[\d]+)$/,
 359         ~/^refs\/tags\/(Ubuntu-hwe-5\.13-5\.13\.0-.*_20\.04\.\d+)$/,
 360         ~/^refs\/tags\/(Ubuntu-hwe-5\.15-5\.15\.0-.*_20\.04\.\d+)$/,
 361       ]
 362       break
 363
 364     case 'noble':
 365       matchStrs = [
 366         ~/^refs\/tags\/(Ubuntu-6\.8\.0-\d{1,3}?\.[\d]+)$/,
 367       ]
 368       break
 369
 370     default:
 371       println "Unsupported Ubuntu version: ${uversion}"
 372       throw new InterruptedException()
 373       break
 374   }
 375 } else {
 376   // Vanilla
 377   kversionFactory = new VanillaKVersion()
 378   matchStrs = [
 379     ~/^refs\/tags\/(v[\d\.]+(-rc(\d+))?)$/,
 380   ]
 381   blacklist = [
 382     'v3.2.3',
 383   ]
 384 }
 385
 386 // Parse kernel versions
 387 def kverfloor = ""
 388 try {
 389     kverfloor = kversionFactory.factory(kverfloor_raw)
 390 } catch (EmptyKVersionException e) {
 391     kverfloor = kversionFactory.minKVersion()
 392 }
 393
 394 def kverceil = ""
 395 try {
 396     kverceil = kversionFactory.factory(kverceil_raw)
 397 } catch (EmptyKVersionException e) {
 398     kverceil = kversionFactory.maxKVersion()
 399 }
 400
 401 // Build a sorted list of versions to build
 402 for (ref in refs) {
 403   for (matchStr in matchStrs) {
 404     def match = ref.getName() =~ matchStr
 405     if (match && !blacklist.contains(match.group(1))) {
 406       def v = kversionFactory.factory(match.group(1))
 407
 408       if ((v >= kverfloor) && (v < kverceil)) {
 409         if (v.isRC()) {
 410           kversionsRC.add(v)
 411         } else {
 412           kversions.add(v)
 413         }
 414       }
 415     }
 416   }
 417 }
 418
 419 // The filtering step assumes the version lists are sorted
 420 kversions.sort()
 421 kversionsRC.sort()
 422
 423 switch (kverfilter) {
 424   case 'stable-head':
 425     // Keep only the head of each stable branch
 426     println('Filter kernel versions to keep only the latest point release of each stable branch.')
 427
 428     for (i = 0; i < kversions.size(); i++) {
 429       def curr = kversions[i]
 430       def next = i < kversions.size() - 1 ? kversions[i + 1] : null
 431
 432       if (next != null) {
 433         if (curr.isSameStable(next)) {
 434           kversions.remove(i)
 435           i--
 436         }
 437       }
 438     }
 439     break
 440
 441   case 'lts-head':
 442     // Keep only the head of each LTS branch and the latest non-RC tag
 443     println('Filter kernel versions to keep only the latest point release of each lts branch and the current stable.')
 444
 445     def lts_kversions = []
 446     // Old LTS entries are kept so that "lts-head" is still meaningful in kernel
 447     // version ranges that are supported by lttng-modules but no longer supported
 448     // upstream, eg. lttng-modules stable-2.13 supports >= 3.0
 449     lts_kversions.add(kversionFactory.factory("v3.0"))  // LTS until October 2013
 450     lts_kversions.add(kversionFactory.factory("v3.2"))  // LTS until May 2018
 451     lts_kversions.add(kversionFactory.factory("v3.4"))  // LTS until October 2016
 452     lts_kversions.add(kversionFactory.factory("v3.10")) // LTS until November 2017
 453     lts_kversions.add(kversionFactory.factory("v3.12")) // LTS until May 2017
 454     lts_kversions.add(kversionFactory.factory("v3.14")) // LTS until August 2016
 455     lts_kversions.add(kversionFactory.factory("v3.16")) // LTS until October 2014
 456     lts_kversions.add(kversionFactory.factory("v3.18")) // LTS until January 2017
 457     lts_kversions.add(kversionFactory.factory("v4.1"))  // LTS until May 2018
 458     lts_kversions.add(kversionFactory.factory("v4.4"))  // SLTS until 2026
 459     lts_kversions.add(kversionFactory.factory("v4.9"))  // LTS until January 2023
 460     lts_kversions.add(kversionFactory.factory("v4.14")) // LTS until January 2024
 461     lts_kversions.add(kversionFactory.factory("v4.19")) // LTS until December 2024
 462     lts_kversions.add(kversionFactory.factory("v5.4"))  // LTS until December 2025
 463     lts_kversions.add(kversionFactory.factory("v5.10")) // LTS until December 2026
 464     lts_kversions.add(kversionFactory.factory("v5.15")) // LTS until December 2026
 465     lts_kversions.add(kversionFactory.factory("v6.1"))  // LTS until December 2026
 466     lts_kversions.add(kversionFactory.factory("v6.6"))  // LTS until December 2026
 467
 468     // First filter the head of each branch
 469     for (i = 0; i < kversions.size(); i++) {
 470       def curr = kversions[i]
 471       def next = i < kversions.size() - 1 ? kversions[i + 1] : null
 472
 473       if (next != null) {
 474         if (curr.isSameStable(next)) {
 475           kversions.remove(i)
 476           i--
 477         }
 478       }
 479     }
 480
 481     for (i = 0; i < kversions.size(); i++) {
 482       def curr = kversions[i]
 483
 484       // Keep the newest tag
 485       if (i == kversions.size() - 1) {
 486         break
 487       }
 488
 489       // Prune non-LTS versions
 490       def keep = false
 491       for (j = 0; j < lts_kversions.size(); j++) {
 492         if (curr.isSameStable(lts_kversions[j])) {
 493           keep = true
 494           break
 495         }
 496       }
 497
 498       if (!keep) {
 499         kversions.remove(i)
 500         i--
 501       }
 502     }
 503     break
 504
 505   default:
 506     // No filtering of kernel versions
 507     println('No kernel versions filtering selected.')
 508     break
 509 }
 510
 511 if (kverrc == "true") {
 512   // If the last RC version is newer than the last stable, add it to the build list
 513   if (kversionsRC.size() > 0 && kversionsRC.last() > kversions.last()) {
 514     kversions.add(kversionsRC.last())
 515   }
 516 }
 517
 518 println "Building the following kernel versions:"
 519 for (k in kversions) {
 520   println k
 521 }
 522
 523 // Debug: Stop build here
 524 //throw new InterruptedException()
 525
 526 def joburl = HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
 527
 528 def allBuilds = []
 529 def ongoingBuild = []
 530 def failedRuns = []
 531 def isFailed = false
 532 def similarJobQueued = 0;
 533
 534 // Loop while we have kernel versions remaining or jobs running
 535 while ( kversions.size() != 0 || ongoingBuild.size() != 0 ) {
 536
 537   if(ongoingBuild.size() < maxConcurrentBuild.toInteger() && kversions.size() != 0) {
 538     def kversion = kversions.pop()
 539     def job_params = [
 540       new StringParameterValue('mversion', mbranch),
 541       new StringParameterValue('mgitrepo', mgitrepo),
 542       new StringParameterValue('ktag', kversion.toString()),
 543       new StringParameterValue('kgitrepo', kgitrepo),
 544     ]
 545
 546     // Launch the parametrized build
 547     def param_build = job.scheduleBuild2(0, new Cause.UpstreamCause(build), new ParametersAction(job_params))
 548     println "triggering ${joburl} for the ${mbranch} branch on kernel ${kversion}"
 549
 550     // Add it to the ongoing build queue
 551     ongoingBuild.push(param_build)
 552
 553   } else {
 554
 555     println "Waiting... Queued: " + kversions.size() + " Running: " + ongoingBuild.size()
 556     try {
 557       Thread.sleep(10000)
 558     } catch(e) {
 559       if (e in InterruptedException) {
 560         build.setResult(hudson.model.Result.ABORTED)
 561         throw new InterruptedException()
 562       } else {
 563         throw(e)
 564       }
 565     }
 566
 567     // Abort job if a newer instance is queued
 568     if (!currentJobName.contains("gerrit")) {
 569       similarJobQueued = Hudson.instance.queue.items.count{it.task.getFullDisplayName() == currentJobName}
 570       if (similarJobQueued > 0) {
 571         println "Abort, a newer instance of the job was queued"
 572         build.setResult(hudson.model.Result.ABORTED)
 573         throw new InterruptedException()
 574       }
 575     }
 576
 577     def i = ongoingBuild.iterator()
 578     while ( i.hasNext() ) {
 579       currentBuild = i.next()
 580       if ( currentBuild.isCancelled() || currentBuild.isDone() ) {
 581         // Remove from queue
 582         i.remove()
 583
 584         // Print results
 585         def matrixParent = currentBuild.get()
 586         allBuilds.add(matrixParent)
 587         def kernelStr = matrixParent.buildVariableResolver.resolve("ktag")
 588         println "${matrixParent.fullDisplayName} (${kernelStr}) completed with status ${matrixParent.result}"
 589
 590         // Process child runs of matrixBuild
 591         def childRuns = matrixParent.getRuns()
 592         for ( childRun in childRuns ) {
 593           println "\t${childRun.fullDisplayName} (${kernelStr}) completed with status ${childRun.result}"
 594           if (childRun.result != Result.SUCCESS) {
 595             failedRuns.add(childRun)
 596             isFailed = true
 597           }
 598         }
 599       }
 600     }
 601   }
 602 }
 603
 604 // Get log of failed runs
 605 for (failedRun in failedRuns) {
 606   println "---START---"
 607   failedRun.writeWholeLogTo(out)
 608   println "---END---"
 609 }
 610
 611 println "---Build report---"
 612 for (b in allBuilds) {
 613   def kernelStr = b.buildVariableResolver.resolve("ktag")
 614   println "${b.fullDisplayName} (${kernelStr}) completed with status ${b.result}"
 615   // Cleanup builds
 616   try {
 617     b.delete()
 618   } catch (all) {}
 619 }
 620
 621 // Mark this build failed if any child build has failed
 622 if (isFailed) {
 623   build.setResult(hudson.model.Result.FAILURE)
 624 }
 625
 626 // EOF