dsl/kernel-lttng-modules.seed.groovy

   1 enum KernelVersioning {
   2     MAJOR,MINOR,REVISION,BUILD
   3 }
   4
   5 class KernelVersion implements Comparable<KernelVersion> {
   6     int major = -1
   7     int minor = -1
   8     int revision = -1
   9     int build = -1
  10     int rc = -1
  11
  12     // Default Constructor
  13     KernelVersion() {}
  14
  15     // Parse a version string of format X,Y,Z,W-A
  16     KernelVersion(String version) {
  17         def tokenVersion
  18         def token
  19         if (version.contains('-')) {
  20             // Release canditate
  21             token = version.tokenize('-')
  22             tokenVersion = token[0]
  23             if (token[1].isInteger()) {
  24                 rc = token[1].toInteger()
  25             }
  26         } else {
  27             tokenVersion = version
  28         }
  29
  30         tokenVersion = tokenVersion.tokenize('.')
  31
  32         def tagEnum = KernelVersioning.MAJOR
  33         tokenVersion.each {
  34             if (it.isInteger()) {
  35                 switch (tagEnum) {
  36                     case KernelVersioning.MAJOR:
  37                         major = it.toInteger()
  38                         tagEnum = KernelVersioning.MINOR
  39                         break
  40                     case KernelVersioning.MINOR:
  41                         minor = it.toInteger()
  42                         tagEnum = KernelVersioning.REVISION
  43                         break
  44                     case KernelVersioning.REVISION:
  45                         revision = it.toInteger()
  46                         tagEnum = KernelVersioning.BUILD
  47                         break
  48                     case KernelVersioning.BUILD:
  49                         build = it.toInteger()
  50                         tagEnum = -1
  51                         break
  52                     default:
  53                         println("Unsupported version extension")
  54                         println("Trying to parse: ${version}")
  55                         println("Invalid sub version value: ${it}")
  56                 //TODO: throw exception for jenkins
  57                 }
  58             }
  59         }
  60     }
  61
  62
  63     String print() {
  64         String ret = ""
  65         if (major != -1) {
  66             ret += major
  67             if (minor != -1) {
  68                 ret += "." + minor
  69                 if (revision != -1) {
  70                     ret += "." + revision
  71                     if (build != -1) {
  72                         ret += "." + build
  73                     }
  74                 }
  75             }
  76             if (rc != -1) {
  77                 ret += "-" + rc
  78             }
  79         }
  80         return ret
  81     }
  82
  83     @Override
  84     int compareTo(KernelVersion kernelVersion) {
  85         return major <=> kernelVersion.major ?: minor <=> kernelVersion.minor ?: revision <=> kernelVersion.revision ?: build <=> kernelVersion.build ?: rc <=> kernelVersion.rc
  86     }
  87 }
  88
  89 def cutoff = [major: 3, minor:19,revision:-1, build:-1, rc:-1]
  90 def linuxURL = "git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git"
  91 def modulesURL = "git://git.lttng.org/lttng-modules.git"
  92
  93 // Linux specific variable
  94 String linuxCheckoutTo = "linux-source"
  95 String recipeCheckoutTo = "recipe"
  96 String modulesCheckoutTo = "lttng-modules"
  97
  98 def linuxGitReference = "/home/jenkins/gitcache/linux-stable.git"
  99 String process = "git ls-remote -t $linuxURL | cut -c42- | sort -V"
 100
 101 // Check if we run the script on a jenkins instance
 102 // This is useful for dev and debug locally on groovy feature and not jenkins specific stuff
 103 def isJenkinsInstance = binding.variables.containsKey('JENKINS_HOME')
 104
 105
 106 // Split the string into sections based on |
 107 // And pipe the results together
 108 def out = new StringBuilder()
 109 def err = new StringBuilder()
 110 Process result = process.tokenize( '|' ).inject( null ) { p, c ->
 111     if( p )
 112         p | c.execute()
 113     else
 114         c.execute()
 115 }
 116
 117 result.waitForProcessOutput(out,err)
 118
 119 if ( result.exitValue() == 0 ) {
 120     def branches = out.readLines().collect {
 121         it.replaceAll("\\^\\{\\}", '').replaceAll("rc", '').replaceAll(/refs\/tags\/v/,'')
 122     }
 123
 124     branches = branches.unique()
 125     List versions = []
 126
 127     branches.each { branch ->
 128         KernelVersion kVersion = new KernelVersion(branch.toString())
 129         versions.add(kVersion)
 130     }
 131
 132     // Sort the version
 133     versions = versions.sort()
 134
 135     // Find cut of
 136     def cutoffPos = versions.findIndexOf{(it.major >= cutoff.major) && (it.minor >= cutoff.minor) && (it.revision >= cutoff.revision) && (it.build >= cutoff.build) && (it.rc >= cutoff.rc)}
 137
 138
 139     // Get last version and include only last rc
 140     def last
 141     def lastNoRcPos
 142     last = versions.last()
 143     if (last.rc != -1) {
 144         int i = versions.size()-1
 145         while (i > -1 && versions[i].rc != -1 ) {
 146             i--
 147         }
 148         lastNoRcPos = i + 1
 149     } else {
 150         lastNoRcPos = versions.size()
 151     }
 152
 153     for (int i = cutoffPos; i < versions.size() ; i++) {
 154         if ( (i < lastNoRcPos && versions[i].rc == -1) || (i >= lastNoRcPos)) {
 155             println ("Preparing job for")
 156             String kernel = versions[i].print()
 157             String jobName = "kernel-${kernel}"
 158             String moduleJobName = "lttng-modules-master-kernel-${kernel}"
 159             println(jobName)
 160             println(moduleJobName)
 161         if (isJenkinsInstance) {
 162             matrixJob("${jobName}") {
 163                 using("linux-master")
 164                 scm {
 165                     git {
 166                         remote {
 167                             url("${linuxURL}")
 168                         }
 169                         branch(tag)
 170                         shallowClone(true)
 171                         relativeTargetDir(linuxCheckoutTo)
 172                         reference(linuxGitReference)
 173                     }
 174                 }
 175                 publishers {
 176                     downstream(moduleJobName, 'SUCCESS')
 177                 }
 178             }
 179             // Corresponding Module job
 180             matrixJob("${moduleJobName}") {
 181                 using("modules")
 182                 multiscm {
 183                     git {
 184                         remote {
 185                             name("linux")
 186                             url("${linuxURL}")
 187                         }
 188                         branch(tag)
 189                         shallowClone(true)
 190                         relativeTargetDir(linuxCheckoutTo)
 191                         reference(linuxGitReference)
 192                     }
 193                     git {
 194                         remote {
 195                             name("lttng-modules")
 196                             url(modulesURL)
 197                         }
 198                         branch("master")
 199                         relativeTargetDir(modulesCheckoutTo)
 200                     }
 201                 }
 202                 steps {
 203                     copyArtifacts("${jobName}/arch=\$arch", "linux-artifact/**", '', false, false) {
 204                         latestSuccessful(true) // Latest successful build
 205                     }
 206                     shell(readFileFromWorkspace('lttng-modules/lttng-modules-dsl-master.sh'))
 207                 }
 208             }
 209         }
 210         }
 211     }
 212 }
 213