[lttng-ci.git] / dsl / kernel-lttng-modules.seed.groovy.orig

enum KernelVersioning {
    MAJOR,MINOR,REVISION,BUILD
}

class BasicVersion implements Comparable<BasicVersion> {
    int major = -1
    int minor = -1
    int revision = -1
    int build = -1
    int rc = -1
    String gitRefs

    // Default Constructor
    BasicVersion() {}

    // 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()) {
                rc = token[1].toInteger()
            }
        } else {
            tokenVersion = version
        }

        tokenVersion = tokenVersion.tokenize('.')

        def tagEnum = KernelVersioning.MAJOR
        tokenVersion.each {
            if (it?.isInteger()) {
                switch (tagEnum) {
                    case KernelVersioning.MAJOR:
                        major = it.toInteger()
                        tagEnum = KernelVersioning.MINOR
                        break
                    case KernelVersioning.MINOR:
                        minor = it.toInteger()
                        tagEnum = KernelVersioning.REVISION
                        break
                    case KernelVersioning.REVISION:
                        revision = it.toInteger()
                        tagEnum = KernelVersioning.BUILD
                        break
                    case KernelVersioning.BUILD:
                        build = it.toInteger()
                        tagEnum = -1
                        break
                    default:
                        println("Unsupported version extension")
                        println("Trying to parse: ${version}")
                        println("Invalid sub version value: ${it}")
                //TODO: throw exception for jenkins
                }
            }
        }
    }

    String print() {
        String ret = ""
        if (major != -1) {
            ret += major
            if (minor != -1) {
                ret += "." + minor
                if (revision != -1) {
                    ret += "." + revision
                    if (build != -1) {
                        ret += "." + build
                    }
                }
            }
            if (rc != -1) {
                ret += "-rc" + rc
            }
        }
        return ret
    }

    @Override
    int compareTo(BasicVersion kernelVersion) {
        return major <=> kernelVersion.major ?: minor <=> kernelVersion.minor ?: revision <=> kernelVersion.revision ?: build <=> kernelVersion.build ?: rc <=> kernelVersion.rc
    }
}

<<<<<<< HEAD
def kernelTagCutOff = new BasicVersion("3.0", "")
def modulesBranches = ["master","stable-2.5","stable-2.6", "stable-2.4"]
=======
def kernelTagCutOff = new BasicVersion("4.0", "")
def modulesBranches = ["master","stable-2.5.0","stable-2.6.0", "stable-2.4.0"]
>>>>>>> parent of badc51e... demo


def linuxURL = "git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git"
def modulesURL = "git://git.lttng.org/lttng-modules.git"

// Linux specific variable
String linuxCheckoutTo = "linux-source"
String recipeCheckoutTo = "recipe"
String modulesCheckoutTo = "lttng-modules"

def linuxGitReference = "/home/jenkins/gitcache/linux-stable.git"

// 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 ->
    if( p )
        p | c.execute()
    else
        c.execute()
}

result.waitForProcessOutput(out,err)

if ( result.exitValue() == 0 ) {
    def branches = out.readLines().collect {
        // Scrap special string tag
        it.replaceAll("\\^\\{\\}", '')
    }

    branches = branches.unique()

    List versions = []
    branches.each { branch ->
        def stripBranch = branch.replaceAll("rc", '').replaceAll(/refs\/tags\/v/,'')
        BasicVersion kVersion = new BasicVersion(stripBranch, branch)
        versions.add(kVersion)
    }

    // Sort the version via Comparable implementation of KernelVersion
    versions = versions.sort()

    // 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)}

    // Get last version and include only last rc
    def last
    def lastNoRcPos
    last = versions.last()
    if (last.rc != -1) {
        int i = versions.size()-1
        while (i > -1 && versions[i].rc != -1 ) {
            i--
        }
        lastNoRcPos = i + 1
    } else {
        lastNoRcPos = versions.size()
    }

    String modulesPrefix = "lttng-modules"
    String kernelPrefix = "dsl-kernel"
    String separator = "-"
    // 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 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)
            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')
                        }
                    }
                }
            }
            // Corresponding Module job
            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)
                            }
                        }
                        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)
            }
		}

		modulesBranches.each { branch ->
			freeStyleJob("dsl-trigger-module-${branch}") {
				steps {
					systemGroovyCommand(dslTriggerModule.replaceAll("JOBPREFIX",modulesPrefix + separator + branch + separator))
				}
			}
		}
    }
}
Commit	Line	Data
d983aa06 JR	1	enum KernelVersioning {
	2	MAJOR,MINOR,REVISION,BUILD
	3	}
	4
	5	class BasicVersion implements Comparable<BasicVersion> {
	6	int major = -1
	7	int minor = -1
	8	int revision = -1
	9	int build = -1
	10	int rc = -1
	11	String gitRefs
	12
	13	// Default Constructor
	14	BasicVersion() {}
	15
	16	// Parse a version string of format X.Y.Z.W-A
	17	BasicVersion(String version, String ref) {
	18	gitRefs = ref
	19	def tokenVersion
	20	def token
	21	if (version.contains('-')) {
	22	// Release canditate
	23	token = version.tokenize('-')
	24	tokenVersion = token[0]
	25	if (token[1]?.isInteger()) {
	26	rc = token[1].toInteger()
	27	}
	28	} else {
	29	tokenVersion = version
	30	}
	31
	32	tokenVersion = tokenVersion.tokenize('.')
	33
	34	def tagEnum = KernelVersioning.MAJOR
	35	tokenVersion.each {
	36	if (it?.isInteger()) {
	37	switch (tagEnum) {
	38	case KernelVersioning.MAJOR:
	39	major = it.toInteger()
	40	tagEnum = KernelVersioning.MINOR
	41	break
	42	case KernelVersioning.MINOR:
	43	minor = it.toInteger()
	44	tagEnum = KernelVersioning.REVISION
	45	break
	46	case KernelVersioning.REVISION:
	47	revision = it.toInteger()
	48	tagEnum = KernelVersioning.BUILD
	49	break
	50	case KernelVersioning.BUILD:
	51	build = it.toInteger()
	52	tagEnum = -1
	53	break
	54	default:
	55	println("Unsupported version extension")
	56	println("Trying to parse: ${version}")
	57	println("Invalid sub version value: ${it}")
	58	//TODO: throw exception for jenkins
	59	}
	60	}
	61	}
	62	}
	63
	64	String print() {
65	String ret = ""
66	if (major != -1) {
67	ret += major
68	if (minor != -1) {
69	ret += "." + minor
70	if (revision != -1) {
71	ret += "." + revision
72	if (build != -1) {
73	ret += "." + build
74	}
75	}
76	}
77	if (rc != -1) {
78	ret += "-rc" + rc
79	}
80	}
81	return ret
82	}
83
84	@Override
85	int compareTo(BasicVersion kernelVersion) {
86	return major <=> kernelVersion.major ?: minor <=> kernelVersion.minor ?: revision <=> kernelVersion.revision ?: build <=> kernelVersion.build ?: rc <=> kernelVersion.rc
87	}
88	}
89
90	<<<<<<< HEAD
91	def kernelTagCutOff = new BasicVersion("3.0", "")
92	def modulesBranches = ["master","stable-2.5","stable-2.6", "stable-2.4"]
93	=======
94	def kernelTagCutOff = new BasicVersion("4.0", "")
95	def modulesBranches = ["master","stable-2.5.0","stable-2.6.0", "stable-2.4.0"]
96	>>>>>>> parent of badc51e... demo
97
98
99	def linuxURL = "git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git"
100	def modulesURL = "git://git.lttng.org/lttng-modules.git"
101
102	// Linux specific variable
103	String linuxCheckoutTo = "linux-source"
104	String recipeCheckoutTo = "recipe"
105	String modulesCheckoutTo = "lttng-modules"
106
107	def linuxGitReference = "/home/jenkins/gitcache/linux-stable.git"
108
109	// Check if we are on jenkins
110	// Useful for outside jenkins devellopment related to groovy only scripting
111	def isJenkinsInstance = binding.variables.containsKey('JENKINS_HOME')
112
113	// Fetch tags and format
114	// Split the string into sections based on \|
115	// And pipe the results together
116	String process = "git ls-remote -t $linuxURL \| cut -c42- \| sort -V"
117	def out = new StringBuilder()
118	def err = new StringBuilder()
119	Process result = process.tokenize( '\|' ).inject( null ) { p, c ->
120	if( p )
121	p \| c.execute()
122	else
123	c.execute()
124	}
125
126	result.waitForProcessOutput(out,err)
127
128	if ( result.exitValue() == 0 ) {
129	def branches = out.readLines().collect {
130	// Scrap special string tag
131	it.replaceAll("\\^\\{\\}", '')
132	}
133
134	branches = branches.unique()
135
136	List versions = []
137	branches.each { branch ->
138	def stripBranch = branch.replaceAll("rc", '').replaceAll(/refs\/tags\/v/,'')
139	BasicVersion kVersion = new BasicVersion(stripBranch, branch)
140	versions.add(kVersion)
141	}
142
143	// Sort the version via Comparable implementation of KernelVersion
144	versions = versions.sort()
145
146	// Find the version cutoff
147	def cutoffPos = versions.findIndexOf{(it.major >= kernelTagCutOff.major) && (it.minor >= kernelTagCutOff.minor) && (it.revision >= kernelTagCutOff.revision) && (it.build >= kernelTagCutOff.build) && (it.rc >= kernelTagCutOff.rc)}
148
149	// Get last version and include only last rc
150	def last
151	def lastNoRcPos
152	last = versions.last()
153	if (last.rc != -1) {
154	int i = versions.size()-1
155	while (i > -1 && versions[i].rc != -1 ) {
156	i--
157	}
158	lastNoRcPos = i + 1
159	} else {
160	lastNoRcPos = versions.size()
161	}
162
163	String modulesPrefix = "lttng-modules"
164	String kernelPrefix = "dsl-kernel"
165	String separator = "-"
166	// Actual job creation
167	for (int i = cutoffPos; i < versions.size() ; i++) {
168
169	// Only create for valid build
170	if ( (i < lastNoRcPos && versions[i].rc == -1) \|\| (i >= lastNoRcPos)) {
171	println ("Preparing job for")
172
173	String jobName = kernelPrefix + separator + versions[i].print()
174
175	// Generate modules job based on supported modules jobs
176	def modulesJob = [:]
177	modulesBranches.each { branch ->
178	modulesJob[branch] = modulesPrefix + separator + branch + separator + jobName
179	}
180
181	// Jenkins only dsl
182	println(jobName)
183	if (isJenkinsInstance) {
184	matrixJob("${jobName}") {
185	using("linux-master")
186	scm {
187	git {
188	remote {
189	url("${linuxURL}")
190	}
191	branch(versions[i].gitRefs)
192	shallowClone(true)
193	relativeTargetDir(linuxCheckoutTo)
194	reference(linuxGitReference)
195	}
196	}
197	publishers {
198	modulesJob.each {
199	downstream(it.value, 'SUCCESS')
200	}
201	}
202	}
203	}
204	// Corresponding Module job
205	modulesJob.each { job ->
206	println("\t" + job.key + " " + job.value)
207	if (isJenkinsInstance) {
208	matrixJob(job.value) {
209	using("modules")
210	multiscm {
211	git {
212	remote {
213	name(kernelPrefix)
214	url("${linuxURL}")
215	}
216	branch(versions[i].gitRefs)
217	shallowClone(true)
218	relativeTargetDir(linuxCheckoutTo)
219	reference(linuxGitReference)
220	}
221	git {
222	remote {
223	name(modulesPrefix)
224	url(modulesURL)
225	}
226	branch(job.key)
227	relativeTargetDir(modulesCheckoutTo)
228	}
229	}
230	steps {
231	copyArtifacts("${jobName}/arch=\$arch", "linux-artifact/**", '', false, false) {
232	latestSuccessful(true) // Latest successful build
233	}
234	shell(readFileFromWorkspace('lttng-modules/lttng-modules-dsl-master.sh'))
235	}
236	}
237	}
238	}
239	}
240	}
241
242	// Trigger generations
243	def dslTriggerKernel = """\
244
245	import hudson.model.*
246	import hudson.AbortException
247	import hudson.console.HyperlinkNote
248	import java.util.concurrent.CancellationException
249
250
251	def jobs = hudson.model.Hudson.instance.items
252	def fail = false
253	def jobStartWith = "${kernelPrefix}"
254
255	def anotherBuild
256	jobs.each { job ->
257	def jobName = job.getName()
258	if (jobName.startsWith(jobStartWith)) {
259	def lastBuild = job.getLastBuild()
260	if (lastBuild == null) {
261	try {
262	def future = job.scheduleBuild2(0, new Cause.UpstreamCause(build))
263	println "\\tWaiting for the completion of " + HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
264	anotherBuild = future.get()
265	} catch (CancellationException x) {
266	throw new AbortException("\${job.fullDisplayName} aborted.")
267	}
268	println HyperlinkNote.encodeTo('/' + anotherBuild.url, anotherBuild.fullDisplayName) + " completed. Result was " + anotherBuild.result
269
270	build.result = anotherBuild.result
271	if (anotherBuild.result != Result.SUCCESS && anotherBuild.result != Result.UNSTABLE) {
272	// We abort this build right here and now.
273	fail = true
274	println("Build Failed")
275	}
276	} else {
277	println("\\tAlready built")
278	}
279	}
280	}
281
282	if (fail){
283	throw new AbortException("Some job failed")
284	}
285	"""
286	def dslTriggerModule = """\
287	import hudson.model.*
288	import hudson.AbortException
289	import hudson.console.HyperlinkNote
290	import java.util.concurrent.CancellationException
291
292
293	def jobs = hudson.model.Hudson.instance.items
294	def fail = false
295	def jobStartWith = "JOBPREFIX"
296
297	def anotherBuild
298	jobs.each { job ->
299	def jobName = job.getName()
300	if (jobName.startsWith(jobStartWith)) {
301	def lastBuild = job.getLastBuild()
302	if (lastBuild == null) {
303	try {
304	def future = job.scheduleBuild2(0, new Cause.UpstreamCause(build))
305	println "\\tWaiting for the completion of " + HyperlinkNote.encodeTo('/' + job.url, job.fullDisplayName)
306	anotherBuild = future.get()
307	} catch (CancellationException x) {
308	throw new AbortException("\${job.fullDisplayName} aborted.")
309	}
310	println HyperlinkNote.encodeTo('/' + anotherBuild.url, anotherBuild.fullDisplayName) + " completed. Result was " + anotherBuild.result
311
312	build.result = anotherBuild.result
313	if (anotherBuild.result != Result.SUCCESS && anotherBuild.result != Result.UNSTABLE) {
314	// We abort this build right here and now.
315	fail = true
316	println("Build Failed")
317	}
318	} else {
319	println("\\tAlready built")
320	}
321	}
322	}
323
324	if (fail){
325	throw new AbortException("Some job failed")
326	}
327	"""
328	if (isJenkinsInstance) {
329	freeStyleJob("dsl-trigger-kernel") {
330	steps {
331	systemGroovyCommand(dslTriggerKernel)
332	}
333	}
334
335	modulesBranches.each { branch ->
336	freeStyleJob("dsl-trigger-module-${branch}") {
337	steps {
338	systemGroovyCommand(dslTriggerModule.replaceAll("JOBPREFIX",modulesPrefix + separator + branch + separator))
339	}
340	}
341	}
342	}
343	}