scripts/lttng-modules/master-rt.groovy

   1 /**
   2  * Copyright (C) 2016-2018 - 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 mbranch = build.getEnvironment(listener).get('GIT_BRANCH').minus('origin/')
 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 def gitmodpath = build.getEnvironment(listener).get('WORKSPACE') + "/src/lttng-modules"
 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 the lttng-modules git url
 179 def gitmodrepo = Git.open(new File(gitmodpath))
 180 def mgitrepo = gitmodrepo.getRepository().getConfig().getString("remote", "origin", "url")
 181
 182 // Get tags from git repository
 183 def refs = Git.lsRemoteRepository().setTags(true).setRemote(kgitrepo).call()
 184
 185 // Get kernel versions to build
 186 def kversions = []
 187 def tagMatchStrs = [
 188   ~/^refs\/tags\/(v[\d\.]+(-rt(\d+)-rebase))$/,
 189 ]
 190 def blacklist = [
 191   ~/v4\.11\.8-rt5-rebase/,
 192   ~/v4\.11\.9-rt6-rebase/,
 193   ~/v4\.11\.9-rt7-rebase/,
 194   ~/v4\.11\.12-rt8-rebase/,
 195   ~/v4\.11\.12-rt9-rebase/,
 196   ~/v4\.11\.12-rt10-rebase/,
 197   ~/v4\.11\.12-rt11-rebase/,
 198   ~/v4\.11\.12-rt12-rebase/,
 199   ~/v4\.11\.12-rt13-rebase/,
 200   ~/v4\.19.*-rebase/,
 201   ~/v3\.6.*-rebase/,
 202   ~/v3\.8.*-rebase/,
 203 ]
 204
 205 def kversionFactory = new RTKVersion()
 206
 207 // Parse kernel versions
 208 def kverfloor = ""
 209 try {
 210     kverfloor = kversionFactory.factory(kverfloor_raw)
 211 } catch (EmptyKVersionException e) {
 212     kverfloor = kversionFactory.minKVersion()
 213 }
 214
 215 def kverceil = ""
 216 try {
 217     kverceil = kversionFactory.factory(kverceil_raw)
 218 } catch (EmptyKVersionException e) {
 219     kverceil = kversionFactory.maxKVersion()
 220 }
 221
 222 // Build a sorted list of versions to build
 223 for (ref in refs) {
 224   for (tagMatchStr in tagMatchStrs) {
 225     def tagMatch = ref.getName() =~ tagMatchStr
 226
 227     if (tagMatch) {
 228       def kversion_raw = tagMatch.group(1)
 229       def blacklisted = false
 230
 231       // Check if the kversion is blacklisted
 232       for (blackMatchStr in blacklist) {
 233         def blackMatch = kversion_raw =~ blackMatchStr
 234
 235         if (blackMatch) {
 236           blacklisted = true
 237           break;
 238         }
 239       }
 240
 241       if (!blacklisted) {
 242         def v = kversionFactory.factory(kversion_raw)
 243
 244         if ((v >= kverfloor) && (v < kverceil)) {
 245           kversions.add(v)
 246         }
 247       }
 248     }
 249   }
 250 }
 251
 252 kversions.sort()
 253
 254 //println "Pre filtering kernel versions:"
 255 //for (k in kversions) {
 256 //  println k
 257 //}
 258
 259 switch (kverfilter) {
 260   case 'stable-head':
 261     // Keep only the head of each stable branch
 262     println('Filter kernel versions to keep only the latest point release of each stable branch.')
 263
 264     for (i = 0; i < kversions.size(); i++) {
 265       def curr = kversions[i]
 266       def next = i < kversions.size() - 1 ? kversions[i + 1] : null
 267
 268       if (next != null) {
 269         if (curr.isSameStable(next)) {
 270           kversions.remove(i)
 271           i--
 272         }
 273       }
 274     }
 275     break
 276
 277   default:
 278     // No filtering of kernel versions
 279     println('No kernel versions filtering selected.')
 280     break
 281 }
 282
 283
 284 println "Building the following kernel versions:"
 285 for (k in kversions) {
 286   println k
 287 }
 288
 289 // Debug: Stop build here
 290 //throw new InterruptedException()
 291
 292 def joburl = HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
 293
 294 def allBuilds = []
 295 def ongoingBuild = []
 296 def failedRuns = []
 297 def isFailed = false
 298 def similarJobQueued = 0;
 299
 300 // Loop while we have kernel versions remaining or jobs running
 301 while ( kversions.size() != 0 || ongoingBuild.size() != 0 ) {
 302
 303   if(ongoingBuild.size() < maxConcurrentBuild.toInteger() && kversions.size() != 0) {
 304     def kversion = kversions.pop()
 305     def job_params = [
 306       new StringParameterValue('mversion', mbranch),
 307       new StringParameterValue('mgitrepo', mgitrepo),
 308       new StringParameterValue('ktag', kversion.toString()),
 309       new StringParameterValue('kgitrepo', kgitrepo),
 310     ]
 311
 312     // Launch the parametrized build
 313     def param_build = job.scheduleBuild2(0, new Cause.UpstreamCause(build), new ParametersAction(job_params))
 314     println "triggering ${joburl} for the ${mbranch} branch on kernel ${kversion}"
 315
 316     // Add it to the ongoing build queue
 317     ongoingBuild.push(param_build)
 318
 319   } else {
 320
 321     println "Waiting... Queued: " + kversions.size() + " Running: " + ongoingBuild.size()
 322     try {
 323       Thread.sleep(10000)
 324     } catch(e) {
 325       if (e in InterruptedException) {
 326         build.setResult(hudson.model.Result.ABORTED)
 327         throw new InterruptedException()
 328       } else {
 329         throw(e)
 330       }
 331     }
 332
 333     // Abort job if a newer instance is queued
 334     similarJobQueued = Hudson.instance.queue.items.count{it.task.getFullDisplayName() == currentJobName}
 335     if ( similarJobQueued > 0 ) {
 336         build.setResult(hudson.model.Result.ABORTED)
 337         throw new InterruptedException()
 338     }
 339
 340     def i = ongoingBuild.iterator()
 341     while ( i.hasNext() ) {
 342       currentBuild = i.next()
 343       if ( currentBuild.isCancelled() || currentBuild.isDone() ) {
 344         // Remove from queue
 345         i.remove()
 346
 347         // Print results
 348         def matrixParent = currentBuild.get()
 349         allBuilds.add(matrixParent)
 350         def kernelStr = matrixParent.buildVariableResolver.resolve("ktag")
 351         println "${matrixParent.fullDisplayName} (${kernelStr}) completed with status ${matrixParent.result}"
 352
 353         // Process child runs of matrixBuild
 354         def childRuns = matrixParent.getRuns()
 355         for ( childRun in childRuns ) {
 356           println "\t${childRun.fullDisplayName} (${kernelStr}) completed with status ${childRun.result}"
 357           if (childRun.result != Result.SUCCESS) {
 358             failedRuns.add(childRun)
 359             isFailed = true
 360           }
 361         }
 362       }
 363     }
 364   }
 365 }
 366
 367 // Get log of failed runs
 368 for (failedRun in failedRuns) {
 369   println "---START---"
 370   failedRun.writeWholeLogTo(out)
 371   println "---END---"
 372 }
 373
 374 println "---Build report---"
 375 for (b in allBuilds) {
 376   def kernelStr = b.buildVariableResolver.resolve("ktag")
 377   println "${b.fullDisplayName} (${kernelStr}) completed with status ${b.result}"
 378   // Cleanup builds
 379   try {
 380     b.delete()
 381   } catch (all) {}
 382 }
 383
 384 // Mark this build failed if any child build has failed
 385 if (isFailed) {
 386   build.setResult(hudson.model.Result.FAILURE)
 387 }
 388
 389 // EOF