X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=scripts%2Flttng-modules%2Fmaster.groovy;h=5c515b7e8497fc83673b9a4b2be296e3808c84e2;hb=cb36638c299f66aad1dc6280f2796afffeb37c1e;hp=5989673b1b06170b933001727df529eaaa3a7f31;hpb=94ff4298157011a4e382f76791d66aa15466806c;p=lttng-ci.git diff --git a/scripts/lttng-modules/master.groovy b/scripts/lttng-modules/master.groovy index 5989673..5c515b7 100644 --- a/scripts/lttng-modules/master.groovy +++ b/scripts/lttng-modules/master.groovy @@ -163,6 +163,241 @@ class VanillaKVersion implements Comparable { } } +class ElKVersion implements Comparable { + Integer major = 0 + Integer minor = 0 + Integer patch = 0 + Integer elmajor = 0 + Integer elminor = 0 + Integer elpatch = 0 + Integer el_release_major = 0 + Integer el_release_minor = 0 + Boolean append_zero_el_release_minor = false + String version_prefix = "" + + ElKVersion() {} + + ElKVersion(version) { + this.parse(version) + } + + static ElKVersion minKVersion() { + return new ElKVersion("kernel-0.0.0-0.0.0.el0_0") + } + + static ElKVersion maxKVersion() { + return new ElKVersion("kernel-" + Integer.MAX_VALUE + ".0.0-0.0.0.el0_0") + } + + static ElKVersion factory(version) { + return new ElKVersion(version) + } + + def parse(version) { + this.major = 0 + this.minor = 0 + this.patch = 0 + this.elmajor = 0 + this.elminor = 0 + this.elpatch = 0 + this.el_release_major = 0 + this.el_release_minor = 0 + this.append_zero_el_release_minor = false + this.version_prefix = "" + + if (!version) { + throw new EmptyKVersionException("Empty kernel version") + } + + // Eg. imports/r8/kernel-4.18.0-513.18.1.el8_9 + // Eg. imports/r9/kernel-5.14.0-362.13.1.el9_3 + // Eg. imports/r8s/kernel-4.18.0-528.el8 + // Eg. imports/r8/kernel-4.18.0-80.1.2.el8_0 + // Eg. imports/r8/kernel-4.18.0-348.el8 + def match = version =~ /^([\w\d\/]*kernel-)??(\d+)\.(\d+)\.(\d+)-(\d+)(\.(\d+))??(\.(\d+))??\.el(\d+)(_(\d+))??$/ + if (!match) { + throw new InvalidKVersionException("Invalid kernel version: ${version}") + } + + if (match.group(1)) { + this.version_prefix = match.group(1) + } + this.major = Integer.parseInt(match.group(2)) + this.minor = Integer.parseInt(match.group(3)) + this.patch = Integer.parseInt(match.group(4)) + this.elmajor = Integer.parseInt(match.group(5)) + if (match.group(7)) { + this.elminor = Integer.parseInt(match.group(7)) + } + if (match.group(9)) { + this.elpatch = Integer.parseInt(match.group(9)) + } + if (match.group(10)) { + this.el_release_major = Integer.parseInt(match.group(10)) + } + if (match.group(12)) { + this.el_release_minor = Integer.parseInt(match.group(12)) + this.append_zero_el_release_minor = true + } + } + + Boolean isRC() { + return false + } + + Boolean isSameStable(ElKVersion o) { + def properties = ['major', 'minor', 'patch', 'elmajor', 'elminor', 'elpatch', 'el_release_major', 'el_release_minor'] + for (property in properties) { + if (this."$property" != o."$property") { + return false + } + } + return true + } + + @Override int compareTo(ElKVersion o) { + def properties = ['major', 'minor', 'patch', 'elmajor', 'elminor', 'elpatch', 'el_release_major', 'el_release_minor'] + for (property in properties) { + if (this."$property" != o."$property") { + return Integer.compare(this."$property", o."$property") + } + } + return 0 + } + + String toString() { + String vString = "${this.version_prefix}${this.major}.${this.minor}.${this.patch}-${this.elmajor}" + // Sometimes a tag can have no elminor, eg. imports/r8/kernel-4.18.0-80.el8 + if (this.elminor != 0) { + vString = vString.concat(".${this.elminor}") + } + if (this.elpatch != 0) { + vString = vString.concat(".${this.elpatch}") + } + vString = vString.concat(".el${this.el_release_major}") + // Some tags have a trailing el_release_minor that is 0, eg. + // imports/r8/kernel-4.18.0-80.1.2.el8 + if (this.el_release_minor != 0 || (this.el_release_minor == 0 && this.append_zero_el_release_minor)) { + vString = vString.concat("_${this.el_release_minor}") + } + return vString + } +} + +class SlesKVersion implements Comparable { + Integer major = 0 + Integer minor = 0 + Integer patch = 0 + Integer slesrelease = 0 + Integer slesmajor = 0 + Integer slesminor = 0 + + SlesKVersion() {} + + SlesKVersion(version) { + this.parse(version) + } + + static SlesKVersion minKVersion() { + return new SlesKVersion("rpm-0.0.0-0.0.0") + } + + static SlesKVersion maxKVersion() { + return new SlesKVersion("rpm-" + Integer.MAX_VALUE + ".0.0-0.0.0") + } + + static SlesKVersion factory(version) { + return new SlesKVersion(version) + } + + def parse(version) { + this.major = 0 + this.minor = 0 + this.patch = 0 + this.slesrelease = 0 + this.slesmajor = 0 + this.slesminor = 0 + + if (!version) { + throw new EmptyKVersionException("Empty kernel version") + } + + // Eg. 5.14.21-150400.22 + // Eg. 5.14.21-150400.24.100.2 + // From tag: rpm-5.14.21-150400.24.100 -> 5.14.21-150400.24.100 + def match = version =~ /^(rpm-)??(\d+)\.(\d+)\.(\d+)-(\d+)\.(\d+)(\.\d+)??$/ + if (!match) { + throw new InvalidKVersionException("Invalid kernel version: ${version}") + } + + this.major = Integer.parseInt(match.group(2)) + this.minor = Integer.parseInt(match.group(3)) + this.patch = Integer.parseInt(match.group(4)) + this.slesrelease = Integer.parseInt(match.group(5)) + this.slesmajor = Integer.parseInt(match.group(6)) + + if (match.group(7) != null) { + this.slesminor = Integer.parseInt(match.group(7).drop(1)) + } + } + + Boolean isRC() { + return false + } + + Boolean isSameStable(SlesKVersion o) { + if (this.major != o.major) { + return false + } + if (this.minor != o.minor) { + return false + } + if (this.patch != o.patch) { + return false + } + if (this.slesrelease != o.slesrelease) { + return false + } + if (this.slesmajor != o.slesmajor) { + return false + } + if (this.slesminor != o.slesminor) { + return false + } + return true + } + + @Override int compareTo(SlesKVersion o) { + if (this.major != o.major) { + return Integer.compare(this.major, o.major) + } + if (this.minor != o.minor) { + return Integer.compare(this.minor, o.minor) + } + if (this.patch != o.patch) { + return Integer.compare(this.patch, o.patch) + } + if (this.slesrelease != o.slesrelease) { + return Integer.compare(this.slesrelease, o.slesrelease) + } + if (this.slesmajor != o.slesmajor) { + return Integer.compare(this.slesmajor, o.slesmajor) + } + if (this.slesminor != o.slesminor) { + return Integer.compare(this.slesminor, o.slesminor) + } + return 0 + } + + String toString() { + String vString = "rpm-${this.major}.${this.minor}.${patch}-${this.slesrelease}.${this.slesmajor}" + if (this.slesminor != 0) { + vString = vString.concat(".${this.slesminor}") + } + return vString + } +} + class UbuntuKVersion implements Comparable { Integer major = 0 @@ -316,6 +551,8 @@ def kverfloor_raw = build.buildVariableResolver.resolve('kverfloor') def kverceil_raw = build.buildVariableResolver.resolve('kverceil') def kverfilter = build.buildVariableResolver.resolve('kverfilter') def kverrc = build.buildVariableResolver.resolve('kverrc') +def elversion = build.buildVariableResolver.resolve('elversion') +def slesversion = build.buildVariableResolver.resolve('slesversion') def uversion = build.buildVariableResolver.resolve('uversion') def job = Hudson.instance.getJob(build.buildVariableResolver.resolve('kbuildjob')) def currentJobName = build.project.getFullDisplayName() @@ -341,8 +578,51 @@ def kversionsRC = [] def matchStrs = [] def blacklist = [] def kversionFactory = "" +def distroversion = "" + +if (elversion != null) { + distroversion = elversion + kversionFactory = new ElKVersion() + switch (elversion) { + case 'el8': + matchStrs = [ + // EL 8 (all) + // ~/^refs\/tags\/(imports\/r8\/kernel-[\d\.-]+.el8.*)$/, + // EL 8.4 + ~/^refs\/tags\/(imports\/r8\/kernel-4\.18\.0-305\.[\d\.-]+.el8.*)$/, + // EL 8.6 + ~/^refs\/tags\/(imports\/r8\/kernel-4\.18\.0-372\.[\d\.-]+.el8.*)$/, + ] + blacklist = [] + break + default: + println ("Unsupport EL version: ${elversion}") + throw new InterruptedException() + break + } +} else if (slesversion != null) { + distroversion = slesversion + kversionFactory = new SlesKVersion() + switch (slesversion) { + case 'sles15sp4': + matchStrs = [ + ~/^refs\/tags\/(rpm-5.14.21-150400\.22(\.\d+)?(\.\d+)?)$/, + ~/^refs\/tags\/(rpm-5.14.21-150400\.24(\.\d+)?(\.\d+)?)$/, + ] + blacklist = [ + // "Retracted", @see https://www.suse.com/support/kb/doc/?id=000019587#SLE15SP4 + 'rpm-5.14.21-150400.24.49', + 'rpm-5.14.21-150400.24.84', + ] + break -if (uversion != null) { + default: + println "Unsupported SLES version: ${slesversion}" + throw new InterruptedException() + break + } +} else if (uversion != null) { + distroversion = uversion kversionFactory = new UbuntuKVersion() switch (uversion) { case 'jammy': @@ -541,6 +821,9 @@ while ( kversions.size() != 0 || ongoingBuild.size() != 0 ) { new StringParameterValue('mgitrepo', mgitrepo), new StringParameterValue('ktag', kversion.toString()), new StringParameterValue('kgitrepo', kgitrepo), + new StringParameterValue('distroversion', distroversion), + new StringParameterValue('getsrc_repo', build.buildVariableResolver.resolve('getsrc_repo')), + new StringParameterValue('getsrc_version', build.buildVariableResolver.resolve('getsrc_version')) ] // Launch the parametrized build