/**
- * Copyright (C) 2016 - Michael Jeanson <mjeanson@efficios.com>
+ * Copyright (C) 2016-2017 - Michael Jeanson <mjeanson@efficios.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
import org.eclipse.jgit.lib.Ref
+class InvalidkVersionException extends Exception {
+ public InvalidkVersionException(String message) {
+ super(message)
+ }
+}
+
+class EmptykVersionException extends Exception {
+ public EmptykVersionException(String message) {
+ super(message)
+ }
+}
+
class kVersion implements Comparable<kVersion> {
Integer major = 0;
this.patch = 0
this.rc = Integer.MAX_VALUE
+ if (!version) {
+ throw new EmptykVersionException("Empty kernel version")
+ }
+
def match = version =~ /^v(\d+)\.(\d+)(\.(\d+))?(\.(\d+))?(-rc(\d+))?$/
if (!match) {
- throw new Exception("Invalid kernel version: ${version}")
+ throw new InvalidkVersionException("Invalid kernel version: ${version}")
}
Integer offset = 0;
return this.rc != Integer.MAX_VALUE
}
+ // Return true if both version are of the same stable branch
+ Boolean isSameStable(kVersion o) {
+ if (this.major != o.major) {
+ return false
+ }
+ if (this.majorB != o.majorB) {
+ return false
+ }
+ if (this.minor != o.minor) {
+ return false
+ }
+
+ return true
+ }
+
@Override int compareTo(kVersion o) {
if (this.major != o.major) {
- return Integer.compare(this.major, o.major);
+ return Integer.compare(this.major, o.major)
}
if (this.majorB != o.majorB) {
- return Integer.compare(this.majorB, o.majorB);
+ return Integer.compare(this.majorB, o.majorB)
}
if (this.minor != o.minor) {
- return Integer.compare(this.minor, o.minor);
+ return Integer.compare(this.minor, o.minor)
}
if (this.patch != o.patch) {
- return Integer.compare(this.patch, o.patch);
+ return Integer.compare(this.patch, o.patch)
}
if (this.rc != o.rc) {
- return Integer.compare(this.rc, o.rc);
+ return Integer.compare(this.rc, o.rc)
}
// Same version
def mversion = build.buildVariableResolver.resolve('mversion')
def maxConcurrentBuild = build.buildVariableResolver.resolve('maxConcurrentBuild')
def kgitrepo = build.buildVariableResolver.resolve('kgitrepo')
-def kverfloor = new kVersion(build.buildVariableResolver.resolve('kverfloor'))
+def kverfloor_raw = build.buildVariableResolver.resolve('kverfloor')
+def kverceil_raw = build.buildVariableResolver.resolve('kverceil')
+def kverfilter = build.buildVariableResolver.resolve('kverfilter')
def job = Hudson.instance.getJob(build.buildVariableResolver.resolve('kbuildjob'))
def currentJobName = build.project.getFullDisplayName()
+// Parse kernel versions
+def kverfloor = new kVersion(kverfloor_raw)
+def kverceil = ""
+
+try {
+ kverceil = new kVersion(kverceil_raw)
+} catch (EmptykVersionException e) {
+ kverceil = new kVersion("v" + Integer.MAX_VALUE + ".0.0")
+}
+
// Get the out variable
def config = new HashMap()
def bindings = getBinding()
config.putAll(bindings.getVariables())
def out = config['out']
-def jlc = new jenkins.model.JenkinsLocationConfiguration()
-def jenkinsUrl = jlc.url
// Get tags from git repository
def refs = Git.lsRemoteRepository().setTags(true).setRemote(kgitrepo).call();
if (match) {
def v = new kVersion(match.group(1))
- if (v >= kverfloor) {
+ if ((v >= kverfloor) && (v < kverceil)) {
if (v.isRC()) {
kversionsRC.add(v)
} else {
kversions.sort()
kversionsRC.sort()
+switch (kverfilter) {
+ case 'stable-head':
+ // Keep only the head of each stable branch
+ println('Filter kernel versions to keep only the latest point release of each stable branch.')
+
+ for (i = 0; i < kversions.size(); i++) {
+ def curr = kversions[i]
+ def next = i < kversions.size() - 1 ? kversions[i + 1] : null
+
+ if (next != null) {
+ if (curr.isSameStable(next)) {
+ kversions.remove(i)
+ i--
+ }
+ }
+ }
+ break
+
+ default:
+ // No filtering of kernel versions
+ println('No kernel versions filtering selected.')
+ break
+}
+
// If the last RC version is newer than the last stable, add it to the build list
if (kversionsRC.last() > kversions.last()) {
kversions.add(kversionsRC.last())
}
}
- // Check for queued similar job since we only want to run latest
- // as Mathieu Desnoyers requirement
+ // If a newer instance of this job is queued, abort to let it run
similarJobQueued = Hudson.instance.queue.items.count{it.task.getFullDisplayName() == currentJobName}
if ( similarJobQueued > 0 ) {
// Abort since new build is queued
def kernelStr = b.buildVariableResolver.resolve("kversion")
println "${b.fullDisplayName} (${kernelStr}) completed with status ${b.result}"
// Cleanup builds
- b.delete()
+ try {
+ b.delete()
+ } catch (all) {}
}
// Mark this build failed if any child build has failed