1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
|
// Import the utility functionality.
import jobs.generation.Utilities;
def project = GithubProject
def static getOSGroup(def os) {
def osGroupMap = ['Ubuntu':'Linux',
'Debian8.2':'Linux',
'OSX':'OSX',
'Windows_NT':'Windows_NT',
'FreeBSD':'FreeBSD',
'CentOS7.1': 'Linux',
'OpenSUSE13.2': 'Linux']
def osGroup = osGroupMap.get(os, null)
assert osGroup != null : "Could not find os group for ${os}"
return osGroupMap[os]
}
// Innerloop build OS's
def osList = ['Ubuntu', 'Debian8.2', 'OSX', 'Windows_NT', 'FreeBSD', 'CentOS7.1', 'OpenSUSE13.2']
def static setMachineAffinity(def job, def os, def architecture) {
if (architecture == 'arm64' && os == 'Windows_NT') {
// For cross compilation
job.with {
label('arm64')
}
} else {
return Utilities.setMachineAffinity(job, os);
}
}
def static getBuildJobName(def configuration, def architecture, def os) {
// If the architecture is x64, do not add that info into the build name.
// Need to change around some systems and other builds to pick up the right builds
// to do that.
switch (architecture) {
case 'x64':
// For now we leave x64 off of the name for compatibility with other jobs
return configuration.toLowerCase() + '_' + os.toLowerCase()
case 'arm64':
case 'arm':
// These are cross builds
return architecture.toLowerCase() + '_cross_' + configuration.toLowerCase() + '_' + os.toLowerCase()
case 'x86':
return architecture.toLowerCase() + '_' + configuration.toLowerCase() + '_' + os.toLowerCase()
default:
println("Unknown architecture: ${architecture}");
assert false
break
}
}
// **************************
// Define the basic inner loop builds for PR and commit. This is basically just the set
// of coreclr builds over linux/osx/freebsd/windows and debug/release. In addition, the windows
// builds will do a couple extra steps.
// **************************
// Adds a trigger for the PR build if one is needed. If isFlowJob is true, then this is the
// flow job that rolls up the build and test for non-windows OS's
def static addPRTrigger(def job, def architecture, def os, def configuration, isFlowJob) {
def osGroup = getOSGroup(os)
switch (architecture) {
case 'x64':
switch (os) {
case 'OpenSUSE13.2':
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build", '(?i).*test\\W+suse.*')
break
case 'Debian8.2':
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build", '(?i).*test\\W+debian.*')
break
case 'Ubuntu':
case 'OSX':
// Only add the trigger for the flow job and only for Release, since Debug is too slow
if (isFlowJob && configuration == 'Release') {
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build and Test")
}
break
case 'CentOS7.1':
case 'OpenSUSE13.2':
assert !isFlowJob
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build")
break
case 'Windows_NT':
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build and Test")
break
case 'FreeBSD':
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build")
break
default:
println("Unknown os: ${os}");
assert false
break
}
break
case 'arm64':
case 'arm':
switch (os) {
case 'Ubuntu':
Utilities.addGithubPRTrigger(job, "${os} ${architecture} Cross ${configuration} Build", "(?i).*test\\W+${os}\\W+${architecture}.*")
break
case 'Windows_NT':
// Set up a private trigger
Utilities.addPrivateGithubPRTrigger(job, "${os} ${architecture} Cross ${configuration} Build",
"(?i).*test\\W+${architecture}\\W+${osGroup}.*", null, ['jashook', 'RussKeldorph', 'gkhanna79', 'briansul', 'cmckinsey', 'jkotas', 'ramarag', 'markwilkie', 'rahku', 'tzwlai', 'weshaggard'])
break
}
break
case 'x86':
// For windows, x86 runs by default
if (os == 'Windows_NT') {
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build")
}
else {
// default trigger
Utilities.addGithubPRTrigger(job, "${os} ${architecture} ${configuration} Build", "(?i).*test\\W+${architecture}\\W+${osGroup}.*")
}
break
default:
println("Unknown architecture: ${architecture}");
assert false
break
}
}
[true, false].each { isPR ->
['arm', 'arm64', 'x64', 'x86'].each { architecture ->
['Debug', 'Release'].each { configuration ->
osList.each { os ->
// Skip totally unimplemented (in CI) configurations.
switch (architecture) {
case 'arm64':
// Windows or cross compiled Ubuntu
if (os != 'Windows_NT' && os != 'Ubuntu') {
println("Skipping ${os} ${architecture}")
return
}
break
case 'arm':
// Only Ubuntu cross implemented
if (os != 'Ubuntu') {
println("Skipping ${os} ${architecture}")
return
}
break
case 'x86':
// Skip non-windows
if (os != 'Windows_NT') {
println("Skipping ${os} ${architecture}")
return
}
break
case 'x64':
// Everything implemented
break
default:
println("Unknown architecture: ${architecture}");
assert false
break
}
// Calculate names
def lowerConfiguration = configuration.toLowerCase()
def jobName = getBuildJobName(configuration, architecture, os)
// Create the new job
def newJob = job(Utilities.getFullJobName(project, jobName, isPR)) {}
setMachineAffinity(newJob, os, architecture)
// Add all the standard options
Utilities.standardJobSetup(newJob, project, isPR)
if (isPR) {
addPRTrigger(newJob, architecture, os, configuration, false)
}
else {
Utilities.addGithubPushTrigger(newJob)
}
def buildCommands = [];
def osGroup = getOSGroup(os)
// Calculate the build steps, archival, and xunit results
switch (os) {
case 'Windows_NT':
switch (architecture) {
case 'x64':
case 'x86':
buildCommands += "build.cmd ${lowerConfiguration} ${architecture}"
// TEMPORARY. Don't run tests for PR jobs on x86
if (architecture == 'x64' || !isPR) {
buildCommands += "tests\\runtest.cmd ${lowerConfiguration} ${architecture}"
}
// Run the rest of the build
// Build the mscorlib for the other OS's
buildCommands += "build.cmd ${lowerConfiguration} ${architecture} linuxmscorlib"
buildCommands += "build.cmd ${lowerConfiguration} ${architecture} freebsdmscorlib"
buildCommands += "build.cmd ${lowerConfiguration} ${architecture} osxmscorlib"
// Zip up the tests directory so that we don't use so much space/time copying
// 10s of thousands of files around.
buildCommands += "powershell -Command \"Add-Type -Assembly 'System.IO.Compression.FileSystem'; [System.IO.Compression.ZipFile]::CreateFromDirectory('.\\bin\\tests\\${osGroup}.${architecture}.${configuration}', '.\\bin\\tests\\tests.zip')\"";
// For windows, pull full test results and test drops for x86/x64
Utilities.addArchival(newJob, "bin/Product/**,bin/tests/tests.zip")
// TEMPORARY. Don't run tests for PR jobs on x86
if (architecture == 'x86' && !isPR) {
Utilities.addXUnitDotNETResults(newJob, 'bin/**/TestRun*.xml')
}
break
case 'arm64':
buildCommands += "build.cmd ${lowerConfiguration} ${architecture} skiptestbuild /toolset_dir C:\\ats"
// Add archival. No xunit results for x64 windows
Utilities.addArchival(newJob, "bin/Product/**")
break
default:
println("Unknown architecture: ${architecture}");
assert false
break
}
break
case 'Ubuntu':
case 'Debian8.2':
case 'OSX':
case 'FreeBSD':
case 'CentOS7.1':
case 'OpenSUSE13.2':
switch (architecture) {
case 'x64':
case 'x86':
// On other OS's we skipmscorlib but run the pal tests
buildCommands += "./build.sh skipmscorlib verbose ${lowerConfiguration} ${architecture}"
buildCommands += "src/pal/tests/palsuite/runpaltests.sh \${WORKSPACE}/bin/obj/${osGroup}.${architecture}.${configuration} \${WORKSPACE}/bin/paltestout"
// Basic archiving of the build
Utilities.addArchival(newJob, "bin/Product/**,bin/obj/*/tests/**")
// And pal tests
Utilities.addXUnitDotNETResults(newJob, '**/pal_tests.xml')
break
case 'arm64':
// We don't run the cross build except on Ubuntu
assert os == 'Ubuntu'
buildCommands += """echo \"Using rootfs in /opt/aarch64-linux-gnu-root\"
ROOTFS_DIR=/opt/aarch64-linux-gnu-root ./build.sh skipmscorlib arm64 cross verbose ${lowerConfiguration}"""
// Basic archiving of the build, no pal tests
Utilities.addArchival(newJob, "bin/Product/**")
break
case 'arm':
// We don't run the cross build except on Ubuntu
assert os == 'Ubuntu'
buildCommands += """echo \"Using rootfs in /opt/arm-liux-genueabihf-root\"
ROOTFS_DIR=/opt/arm-linux-genueabihf-root ./build.sh skipmscorlib arm cross verbose ${lowerConfiguration}"""
// Basic archiving of the build, no pal tests
Utilities.addArchival(newJob, "bin/Product/**")
break
default:
println("Unknown architecture: ${architecture}");
assert false
break
}
break
default:
println("Unknown os: ${os}");
assert false
break
}
newJob.with {
steps {
if (os == 'Windows_NT') {
buildCommands.each { buildCommand ->
batchFile(buildCommand)
}
}
else {
buildCommands.each { buildCommand ->
shell(buildCommand)
}
}
}
}
} // os
} // configuration
} // architecture
} // isPR
// Create the Linux/OSX coreclr test leg for debug and release.
[true, false].each { isPR ->
// Architectures. x64 only at this point
['x64'].each { architecture ->
// Put the OS's supported for coreclr cross testing here
['Ubuntu', 'OSX'].each { os ->
['Debug', 'Release'].each { configuration ->
def lowerConfiguration = configuration.toLowerCase()
def osGroup = getOSGroup(os)
def jobName = getBuildJobName(configuration, architecture, os) + "_tst"
def inputCoreCLRBuildName = Utilities.getFolderName(project) + '/' +
Utilities.getFullJobName(project, getBuildJobName(configuration, architecture, os), isPR)
def inputWindowTestsBuildName = Utilities.getFolderName(project) + '/' +
Utilities.getFullJobName(project, getBuildJobName(configuration, architecture, 'windows_nt'), isPR)
def newJob = job(Utilities.getFullJobName(project, jobName, isPR)) {
// Add parameters for the inputs
parameters {
stringParam('CORECLR_WINDOWS_BUILD', '', 'Build number to copy CoreCLR windows test binaries from')
stringParam('CORECLR_BUILD', '', "Build number to copy CoreCLR ${osGroup} binaries from")
}
steps {
// Set up the copies
// Coreclr build we are trying to test
copyArtifacts(inputCoreCLRBuildName) {
excludePatterns('**/testResults.xml', '**/*.ni.dll')
buildSelector {
buildNumber('${CORECLR_BUILD}')
}
}
// Coreclr build containing the tests and mscorlib
copyArtifacts(inputWindowTestsBuildName) {
excludePatterns('**/testResults.xml', '**/*.ni.dll')
buildSelector {
buildNumber('${CORECLR_WINDOWS_BUILD}')
}
}
// Corefx native components
def corefxNativeCompBinaries =
copyArtifacts("dotnet_corefx/nativecomp_${os.toLowerCase()}_release") {
includePatterns('bin/**')
buildSelector {
latestSuccessful(true)
}
}
// CoreFX Linux binaries
copyArtifacts("dotnet_corefx/${os.toLowerCase()}_release_bld") {
includePatterns('bin/build.pack')
buildSelector {
latestSuccessful(true)
}
}
// Unpack the corefx binaries
shell("unpacker ./bin/build.pack ./bin")
// Unzip the tests first. Exit with 0
shell("unzip -q -o ./bin/tests/tests.zip -d ./bin/tests/Windows_NT.${architecture}.${configuration} || exit 0")
// Execute the tests
shell("""
./tests/runtest.sh \\
--testRootDir=\"\${WORKSPACE}/bin/tests/Windows_NT.${architecture}.${configuration}\" \\
--testNativeBinDir=\"\${WORKSPACE}/bin/obj/${osGroup}.${architecture}.${configuration}/tests\" \\
--coreClrBinDir=\"\${WORKSPACE}/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
--mscorlibDir=\"\${WORKSPACE}/bin/Product/${osGroup}.${architecture}.${configuration}\" \\
--coreFxBinDir=\"\${WORKSPACE}/bin/${osGroup}.AnyCPU.Release\" \\
--coreFxNativeBinDir=\"\${WORKSPACE}/bin/${osGroup}.${architecture}.Release\"""")
}
}
setMachineAffinity(newJob, os, architecture)
Utilities.standardJobSetup(newJob, project, isPR)
Utilities.addXUnitDotNETResults(newJob, '**/coreclrtests.xml')
// Create a build flow to join together the build and tests required to run this
// test.
// Windows CoreCLR build and Linux CoreCLR build (in parallel) ->
// Linux CoreCLR test
def flowJobName = getBuildJobName(configuration, architecture, os) + "_flow"
def fullTestJobName = Utilities.getFolderName(project) + '/' + newJob.name
def newFlowJob = buildFlowJob(Utilities.getFullJobName(project, flowJobName, isPR)) {
buildFlow("""
// Build the input jobs in parallel
parallel (
{ coreclrBuildJob = build(params, '${inputCoreCLRBuildName}') },
{ windowsBuildJob = build(params, '${inputWindowTestsBuildName}') }
)
// And then build the test build
build(params + [CORECLR_BUILD: coreclrBuildJob.build.number,
CORECLR_WINDOWS_BUILD: windowsBuildJob.build.number], '${fullTestJobName}')
""")
// Needs a workspace
configure {
def buildNeedsWorkspace = it / 'buildNeedsWorkspace'
buildNeedsWorkspace.setValue('true')
}
}
Utilities.standardJobSetup(newFlowJob, project, isPR)
if (isPR) {
addPRTrigger(newFlowJob, architecture, os, configuration, true)
}
else {
Utilities.addGithubPushTrigger(newFlowJob)
}
}
}
}
}
|