scripts/lttng-modules/master-rt.groovy

   1 /**
   2  * Copyright (C) 2016-2017 - 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 RTKVersion implements Comparable<RTKVersion> {
  39
  40   Integer major = 0
  41   Integer majorB = 0
  42   Integer minor = 0
  43   Integer patch = 0
  44   Integer rt = 0
  45
  46   RTKVersion() {}
  47
  48   RTKVersion(version) {
  49     this.parse(version)
  50   }
  51
  52   static RTKVersion minKVersion() {
  53     return new RTKVersion("v0.0.0-rt0-rebase")
  54   }
  55
  56   static RTKVersion maxKVersion() {
  57     return new RTKVersion("v" + Integer.MAX_VALUE + ".0.0-rt0-rebase")
  58   }
  59
  60   static RTKVersion factory(version) {
  61     return new RTKVersion(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.rt = 0
  70
  71     if (!version) {
  72       throw new EmptyKVersionException("Empty kernel version")
  73     }
  74
  75     def match = version =~ /^v(\d+)\.(\d+)(\.(\d+))?(\.(\d+))?(-rt(\d+)-rebase)$/
  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     // RT
 100     this.rt = Integer.parseInt(match.group(8))
 101   }
 102
 103   // Return true if both version are of the same stable branch
 104   Boolean isSameStable(RTKVersion o) {
 105     if (this.major != o.major) {
 106       return false
 107     }
 108     if (this.majorB != o.majorB) {
 109       return false
 110     }
 111     if (this.minor != o.minor) {
 112       return false
 113     }
 114
 115     return true
 116   }
 117
 118   @Override int compareTo(RTKVersion o) {
 119     if (this.major != o.major) {
 120       return Integer.compare(this.major, o.major)
 121     }
 122     if (this.majorB != o.majorB) {
 123       return Integer.compare(this.majorB, o.majorB)
 124     }
 125     if (this.minor != o.minor) {
 126       return Integer.compare(this.minor, o.minor)
 127     }
 128     if (this.patch != o.patch) {
 129       return Integer.compare(this.patch, o.patch)
 130     }
 131     if (this.rt != o.rt) {
 132       return Integer.compare(this.rt, o.rt)
 133     }
 134
 135     // Same version
 136     return 0;
 137   }
 138
 139   String toString() {
 140     String vString = "v${this.major}"
 141
 142     if (this.majorB > 0) {
 143       vString = vString.concat(".${this.majorB}")
 144     }
 145
 146     vString = vString.concat(".${this.minor}")
 147
 148     if (this.patch > 0) {
 149       vString = vString.concat(".${this.patch}")
 150     }
 151
 152     if (this.rt > 0) {
 153       vString = vString.concat("-rt${this.rt}-rebase")
 154     }
 155     return vString
 156   }
 157 }
 158
 159
 160 // Retrieve parameters of the current build
 161 def mversion = build.buildVariableResolver.resolve('mversion')
 162 def maxConcurrentBuild = build.buildVariableResolver.resolve('maxConcurrentBuild')
 163 def kgitrepo = build.buildVariableResolver.resolve('kgitrepo')
 164 def kverfloor_raw = build.buildVariableResolver.resolve('kverfloor')
 165 def kverceil_raw = build.buildVariableResolver.resolve('kverceil')
 166 def kverfilter = build.buildVariableResolver.resolve('kverfilter')
 167 def job = Hudson.instance.getJob(build.buildVariableResolver.resolve('kbuildjob'))
 168 def currentJobName = build.project.getFullDisplayName()
 169
 170
 171 // Get the out variable
 172 def config = new HashMap()
 173 def bindings = getBinding()
 174 config.putAll(bindings.getVariables())
 175 def out = config['out']
 176
 177
 178 // Get tags from git repository
 179 def refs = Git.lsRemoteRepository().setTags(true).setRemote(kgitrepo).call();
 180
 181 // Get kernel versions to build
 182 def kversions = []
 183 def tagMatchStrs = [
 184   ~/^refs\/tags\/(v[\d\.]+(-rt(\d+)-rebase))$/,
 185 ]
 186 def blacklist = [
 187   ~/v4\.11\.8-rt5-rebase/,
 188   ~/v4\.11\.9-rt6-rebase/,
 189   ~/v4\.11\.9-rt7-rebase/,
 190   ~/v4\.11\.12-rt8-rebase/,
 191   ~/v4\.11\.12-rt9-rebase/,
 192   ~/v4\.11\.12-rt10-rebase/,
 193   ~/v4\.11\.12-rt11-rebase/,
 194   ~/v4\.11\.12-rt12-rebase/,
 195   ~/v4\.11\.12-rt13-rebase/,
 196   ~/v3\.6.*-rebase/,
 197   ~/v3\.8.*-rebase/,
 198 ]
 199
 200 def kversionFactory = new RTKVersion()
 201
 202 // Parse kernel versions
 203 def kverfloor = ""
 204 try {
 205     kverfloor = kversionFactory.factory(kverfloor_raw)
 206 } catch (EmptyKVersionException e) {
 207     kverfloor = kversionFactory.minKVersion()
 208 }
 209
 210 def kverceil = ""
 211 try {
 212     kverceil = kversionFactory.factory(kverceil_raw)
 213 } catch (EmptyKVersionException e) {
 214     kverceil = kversionFactory.maxKVersion()
 215 }
 216
 217 // Build a sorted list of versions to build
 218 for (ref in refs) {
 219   for (tagMatchStr in tagMatchStrs) {
 220     def tagMatch = ref.getName() =~ tagMatchStr
 221
 222     if (tagMatch) {
 223       def kversion_raw = tagMatch.group(1)
 224       def blacklisted = false
 225
 226       // Check if the kversion is blacklisted
 227       for (blackMatchStr in blacklist) {
 228         def blackMatch = kversion_raw =~ blackMatchStr
 229
 230         if (blackMatch) {
 231           blacklisted = true
 232           break;
 233         }
 234       }
 235
 236       if (!blacklisted) {
 237         def v = kversionFactory.factory(kversion_raw)
 238
 239         if ((v >= kverfloor) && (v < kverceil)) {
 240           kversions.add(v)
 241         }
 242       }
 243     }
 244   }
 245 }
 246
 247 kversions.sort()
 248
 249 //println "Pre filtering kernel versions:"
 250 //for (k in kversions) {
 251 //  println k
 252 //}
 253
 254 switch (kverfilter) {
 255   case 'stable-head':
 256     // Keep only the head of each stable branch
 257     println('Filter kernel versions to keep only the latest point release of each stable branch.')
 258
 259     for (i = 0; i < kversions.size(); i++) {
 260       def curr = kversions[i]
 261       def next = i < kversions.size() - 1 ? kversions[i + 1] : null
 262
 263       if (next != null) {
 264         if (curr.isSameStable(next)) {
 265           kversions.remove(i)
 266           i--
 267         }
 268       }
 269     }
 270     break
 271
 272   default:
 273     // No filtering of kernel versions
 274     println('No kernel versions filtering selected.')
 275     break
 276 }
 277
 278
 279 println "Building the following kernel versions:"
 280 for (k in kversions) {
 281   println k
 282 }
 283
 284 // Debug: Stop build here
 285 //throw new InterruptedException()
 286
 287 def joburl = HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
 288
 289 def allBuilds = []
 290 def ongoingBuild = []
 291 def failedRuns = []
 292 def isFailed = false
 293 def similarJobQueued = 0;
 294
 295 // Loop while we have kernel versions remaining or jobs running
 296 while ( kversions.size() != 0 || ongoingBuild.size() != 0 ) {
 297
 298   if(ongoingBuild.size() < maxConcurrentBuild.toInteger() && kversions.size() != 0) {
 299     def kversion = kversions.pop()
 300     def job_params = [
 301       new StringParameterValue('mversion', mversion),
 302       new StringParameterValue('ktag', kversion.toString()),
 303       new StringParameterValue('kgitrepo', kgitrepo),
 304     ]
 305
 306     // Launch the parametrized build
 307     def param_build = job.scheduleBuild2(0, new Cause.UpstreamCause(build), new ParametersAction(job_params))
 308     println "triggering ${joburl} for the ${mversion} branch on kernel ${kversion}"
 309
 310     // Add it to the ongoing build queue
 311     ongoingBuild.push(param_build)
 312
 313   } else {
 314
 315     println "Waiting... Queued: " + kversions.size() + " Running: " + ongoingBuild.size()
 316     try {
 317       Thread.sleep(10000)
 318     } catch(e) {
 319       if (e in InterruptedException) {
 320         build.setResult(hudson.model.Result.ABORTED)
 321         throw new InterruptedException()
 322       } else {
 323         throw(e)
 324       }
 325     }
 326
 327     // Abort job if a newer instance is queued
 328     similarJobQueued = Hudson.instance.queue.items.count{it.task.getFullDisplayName() == currentJobName}
 329     if ( similarJobQueued > 0 ) {
 330         build.setResult(hudson.model.Result.ABORTED)
 331         throw new InterruptedException()
 332     }
 333
 334     def i = ongoingBuild.iterator()
 335     while ( i.hasNext() ) {
 336       currentBuild = i.next()
 337       if ( currentBuild.isCancelled() || currentBuild.isDone() ) {
 338         // Remove from queue
 339         i.remove()
 340
 341         // Print results
 342         def matrixParent = currentBuild.get()
 343         allBuilds.add(matrixParent)
 344         def kernelStr = matrixParent.buildVariableResolver.resolve("ktag")
 345         println "${matrixParent.fullDisplayName} (${kernelStr}) completed with status ${matrixParent.result}"
 346
 347         // Process child runs of matrixBuild
 348         def childRuns = matrixParent.getRuns()
 349         for ( childRun in childRuns ) {
 350           println "\t${childRun.fullDisplayName} (${kernelStr}) completed with status ${childRun.result}"
 351           if (childRun.result != Result.SUCCESS) {
 352             failedRuns.add(childRun)
 353             isFailed = true
 354           }
 355         }
 356       }
 357     }
 358   }
 359 }
 360
 361 // Get log of failed runs
 362 for (failedRun in failedRuns) {
 363   println "---START---"
 364   failedRun.writeWholeLogTo(out)
 365   println "---END---"
 366 }
 367
 368 println "---Build report---"
 369 for (b in allBuilds) {
 370   def kernelStr = b.buildVariableResolver.resolve("ktag")
 371   println "${b.fullDisplayName} (${kernelStr}) completed with status ${b.result}"
 372   // Cleanup builds
 373   try {
 374     b.delete()
 375   } catch (all) {}
 376 }
 377
 378 // Mark this build failed if any child build has failed
 379 if (isFailed) {
 380   build.setResult(hudson.model.Result.FAILURE)
 381 }
 382
 383 // EOF