X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=dsl%2Fkernel-lttng-modules.seed.groovy;h=e404d834505c2529e8c0cca9eccafa3eb7aef181;hb=45fb418c36660391ec74fd93d4d8bb441776dcbc;hp=03cfcc25a0f4f61f36314a608506c016c649fa97;hpb=017c762b7ec40a52a986983bce934ffee6dc9fe9;p=lttng-ci.git diff --git a/dsl/kernel-lttng-modules.seed.groovy b/dsl/kernel-lttng-modules.seed.groovy index 03cfcc2..e404d83 100644 --- a/dsl/kernel-lttng-modules.seed.groovy +++ b/dsl/kernel-lttng-modules.seed.groovy @@ -1,28 +1,28 @@ -import groovy.transform.Sortable - enum KernelVersioning { MAJOR,MINOR,REVISION,BUILD } -class KernelVersion implements Comparable { +class BasicVersion implements Comparable { int major = -1 int minor = -1 int revision = -1 int build = -1 int rc = -1 + String gitRefs // Default Constructor - KernelVersion() {} + BasicVersion() {} - // Parse a version string of format X,Y,Z,W-A - KernelVersion(String version) { + // Parse a version string of format X.Y.Z.W-A + BasicVersion(String version, String ref) { + gitRefs = ref def tokenVersion def token if (version.contains('-')) { // Release canditate token = version.tokenize('-') tokenVersion = token[0] - if (token[1].isInteger()) { + if (token[1]?.isInteger()) { rc = token[1].toInteger() } } else { @@ -33,7 +33,7 @@ class KernelVersion implements Comparable { def tagEnum = KernelVersioning.MAJOR tokenVersion.each { - if (it.isInteger()) { + if (it?.isInteger()) { switch (tagEnum) { case KernelVersioning.MAJOR: major = it.toInteger() @@ -61,7 +61,6 @@ class KernelVersion implements Comparable { } } - String print() { String ret = "" if (major != -1) { @@ -76,19 +75,23 @@ class KernelVersion implements Comparable { } } if (rc != -1) { - ret += "-" + rc + ret += "-rc" + rc } } return ret } @Override - int compareTo(KernelVersion kernelVersion) { + int compareTo(BasicVersion kernelVersion) { return major <=> kernelVersion.major ?: minor <=> kernelVersion.minor ?: revision <=> kernelVersion.revision ?: build <=> kernelVersion.build ?: rc <=> kernelVersion.rc } } -def cutoff = [major: 3, minor:19,revision:-1, build:-1, rc:-1] +def kernelTagCutOff = new BasicVersion("4.1", "") +def modulesBranches = [] + +//def modulesBranches = ["master","stable-2.5","stable-2.6", "stable-2.4"] + def linuxURL = "git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git" def modulesURL = "git://git.lttng.org/lttng-modules.git" @@ -98,15 +101,15 @@ String recipeCheckoutTo = "recipe" String modulesCheckoutTo = "lttng-modules" def linuxGitReference = "/home/jenkins/gitcache/linux-stable.git" -String process = "git ls-remote -t $linuxURL | cut -c42- | sort -V" -// Check if we run the script on a jenkins instance -// This is useful for dev and debug locally on groovy feature and not jenkins specific stuff +// Check if we are on jenkins +// Useful for outside jenkins devellopment related to groovy only scripting def isJenkinsInstance = binding.variables.containsKey('JENKINS_HOME') - +// Fetch tags and format // Split the string into sections based on | // And pipe the results together +String process = "git ls-remote -t $linuxURL | cut -c42- | sort -V" def out = new StringBuilder() def err = new StringBuilder() Process result = process.tokenize( '|' ).inject( null ) { p, c -> @@ -120,24 +123,29 @@ result.waitForProcessOutput(out,err) if ( result.exitValue() == 0 ) { def branches = out.readLines().collect { - it.replaceAll("\\^\\{\\}", '').replaceAll("rc", '').replaceAll(/refs\/tags\/v/,'') + // Scrap special string tag + it.replaceAll("\\^\\{\\}", '') } branches = branches.unique() - List versions = [] + List versions = [] branches.each { branch -> - KernelVersion kVersion = new KernelVersion(branch.toString()) + def stripBranch = branch.replaceAll("rc", '').replaceAll(/refs\/tags\/v/,'') + BasicVersion kVersion = new BasicVersion(stripBranch, branch) versions.add(kVersion) } - // Sort the version + // Sort the version via Comparable implementation of KernelVersion versions = versions.sort() - // Find cut of - def cutoffPos = versions.findIndexOf{(it.major >= cutoff.major) && (it.minor >= cutoff.minor) && (it.revision >= cutoff.revision) && (it.build >= cutoff.build) && (it.rc >= cutoff.rc)} - + // Find the version cutoff + def cutoffPos = versions.findIndexOf{(it.major >= kernelTagCutOff.major) && (it.minor >= kernelTagCutOff.minor) && (it.revision >= kernelTagCutOff.revision) && (it.build >= kernelTagCutOff.build) && (it.rc >= kernelTagCutOff.rc)} + // If error set cutoff on last so no job are created + if (cutoffPos == -1) { + cutoffPos = versions.size() + } // Get last version and include only last rc def last def lastNoRcPos @@ -152,64 +160,196 @@ if ( result.exitValue() == 0 ) { lastNoRcPos = versions.size() } + String modulesPrefix = "lttng-modules" + String kernelPrefix = "dsl-kernel" + String separator = "-" + + + println("CutOff index") + println(cutoffPos) + + + // Actual job creation for (int i = cutoffPos; i < versions.size() ; i++) { + + // Only create for valid build if ( (i < lastNoRcPos && versions[i].rc == -1) || (i >= lastNoRcPos)) { println ("Preparing job for") - String kernel = versions[i].print() - String jobName = "kernel-${kernel}" - String moduleJobName = "lttng-modules-master-kernel-${kernel}" + + String jobName = kernelPrefix + separator + versions[i].print() + + // Generate modules job based on supported modules jobs + def modulesJob = [:] + modulesBranches.each { branch -> + modulesJob[branch] = modulesPrefix + separator + branch + separator + jobName + } + + // Jenkins only dsl println(jobName) - println(moduleJobName) - if (isJenkinsInstance) { - matrixJob("${jobName}") { - using("linux-master") - scm { - git { - remote { - url("${linuxURL}") + if (isJenkinsInstance) { + matrixJob("${jobName}") { + using("linux-master") + scm { + git { + remote { + url("${linuxURL}") + } + branch(versions[i].gitRefs) + shallowClone(true) + relativeTargetDir(linuxCheckoutTo) + reference(linuxGitReference) + } + } + publishers { + modulesJob.each { + downstream(it.value, 'SUCCESS') } - branch(tag) - shallowClone(true) - relativeTargetDir(linuxCheckoutTo) - reference(linuxGitReference) } - } - publishers { - downstream(moduleJobName, 'SUCCESS') } } // Corresponding Module job - matrixJob("${moduleJobName}") { - using("modules") - multiscm { - git { - remote { - name("linux") - url("${linuxURL}") + modulesJob.each { job -> + println("\t" + job.key + " " + job.value) + if (isJenkinsInstance) { + matrixJob(job.value) { + using("modules") + multiscm { + git { + remote { + name(kernelPrefix) + url("${linuxURL}") + } + branch(versions[i].gitRefs) + shallowClone(true) + relativeTargetDir(linuxCheckoutTo) + reference(linuxGitReference) + } + git { + remote { + name(modulesPrefix) + url(modulesURL) + } + branch(job.key) + relativeTargetDir(modulesCheckoutTo) + } } - branch(tag) - shallowClone(true) - relativeTargetDir(linuxCheckoutTo) - reference(linuxGitReference) - } - git { - remote { - name("lttng-modules") - url(modulesURL) + steps { + copyArtifacts("${jobName}/arch=\$arch", "linux-artifact/**", '', false, false) { + latestSuccessful(true) // Latest successful build + } + shell(readFileFromWorkspace('lttng-modules/lttng-modules-dsl-master.sh')) } - branch("master") - relativeTargetDir(modulesCheckoutTo) - } - } - steps { - copyArtifacts("${jobName}/arch=\$arch", "linux-artifact/**", '', false, false) { - latestSuccessful(true) // Latest successful build } - shell(readFileFromWorkspace('lttng-modules/lttng-modules-dsl-master.sh')) } } } - } } + + // Trigger generations + def dslTriggerKernel = """\ + +import hudson.model.* +import hudson.AbortException +import hudson.console.HyperlinkNote +import java.util.concurrent.CancellationException + + +def jobs = hudson.model.Hudson.instance.items +def fail = false +def jobStartWith = "${kernelPrefix}" + +def anotherBuild +jobs.each { job -> + def jobName = job.getName() + if (jobName.startsWith(jobStartWith)) { + def lastBuild = job.getLastBuild() + if (lastBuild == null) { + try { + def future = job.scheduleBuild2(0, new Cause.UpstreamCause(build)) + println "\\tWaiting for the completion of " + HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName) + anotherBuild = future.get() + } catch (CancellationException x) { + throw new AbortException("\${job.fullDisplayName} aborted.") + } + println HyperlinkNote.encodeTo('/' + anotherBuild.url, anotherBuild.fullDisplayName) + " completed. Result was " + anotherBuild.result + + build.result = anotherBuild.result + if (anotherBuild.result != Result.SUCCESS && anotherBuild.result != Result.UNSTABLE) { + // We abort this build right here and now. + fail = true + println("Build Failed") + } + } else { + println("\\tAlready built") + } + } +} + +if (fail){ + throw new AbortException("Some job failed") +} +""" + def dslTriggerModule = """\ +import hudson.model.* +import hudson.AbortException +import hudson.console.HyperlinkNote +import java.util.concurrent.CancellationException + + +def jobs = hudson.model.Hudson.instance.items +def fail = false +def jobStartWith = "JOBPREFIX" + +def anotherBuild +jobs.each { job -> + def jobName = job.getName() + if (jobName.startsWith(jobStartWith)) { + def lastBuild = job.getLastBuild() + if (lastBuild == null) { + try { + def future = job.scheduleBuild2(0, new Cause.UpstreamCause(build)) + println "\\tWaiting for the completion of " + HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName) + anotherBuild = future.get() + } catch (CancellationException x) { + throw new AbortException("\${job.fullDisplayName} aborted.") + } + println HyperlinkNote.encodeTo('/' + anotherBuild.url, anotherBuild.fullDisplayName) + " completed. Result was " + anotherBuild.result + + build.result = anotherBuild.result + if (anotherBuild.result != Result.SUCCESS && anotherBuild.result != Result.UNSTABLE) { + // We abort this build right here and now. + fail = true + println("Build Failed") + } + } else { + println("\\tAlready built") + } + } +} + +if (fail){ + throw new AbortException("Some job failed") } +""" + if (isJenkinsInstance) { + freeStyleJob("dsl-trigger-kernel") { + steps { + systemGroovyCommand(dslTriggerKernel) + } + triggers { + cron("H 0 * * *") + } + } + modulesBranches.each { branch -> + freeStyleJob("dsl-trigger-module-${branch}") { + steps { + systemGroovyCommand(dslTriggerModule.replaceAll("JOBPREFIX",modulesPrefix + separator + branch + separator)) + } + triggers { + scm('@daily') + } + } + } + } +}