OLD | NEW |
| (Empty) |
1 # -*- python -*- | |
2 # ex: set syntax=python: | |
3 | |
4 # Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. | |
5 # Use of this source code is governed by a BSD-style license that can be | |
6 # found in the LICENSE file. | |
7 | |
8 # This is the buildmaster config file for the 'nacl' bot. It must | |
9 # be installed as 'master.cfg' in your buildmaster's base directory | |
10 # (although the filename can be changed with the --basedir option to | |
11 # 'mktap buildbot master'). | |
12 | |
13 # It has one job: define a dictionary named BuildmasterConfig. This | |
14 # dictionary has a variety of keys to control different aspects of the | |
15 # buildmaster. They are documented in docs/config.xhtml . | |
16 | |
17 # This file follows this naming convention: | |
18 # Factories: f_nacl_[dbg/opt/sdk]_[os] | |
19 # Builders: b_nacl_[dbg/opt/sdk]_[os] | |
20 # BuildDir: [dbg/opt/sdk]-[os] | |
21 # | |
22 # os = xp/linux/mac | |
23 | |
24 from buildbot import locks | |
25 from buildbot.changes import svnpoller | |
26 from buildbot.scheduler import Dependent | |
27 from buildbot.scheduler import Scheduler | |
28 from buildbot.scheduler import Triggerable | |
29 | |
30 # Reload all the python files under master and common | |
31 import master | |
32 reload(master) | |
33 import common | |
34 reload(common) | |
35 | |
36 # These modules come from scripts/master, which must be in the PYTHONPATH. | |
37 import build_utils | |
38 import chromium_step | |
39 import master_utils | |
40 from master.factory import nacl_factory | |
41 from master.factory import chromium_factory | |
42 import slaves_list | |
43 | |
44 # These modules come from scripts/common, which must be in the PYTHONPATH. | |
45 import chromium_config as config | |
46 import chromium_utils | |
47 | |
48 ActiveMaster = config.Master.NativeClient | |
49 | |
50 TREE_GATE_KEEPER = ActiveMaster.is_production_host | |
51 GOOD_REVISIONS = ActiveMaster.is_production_host | |
52 | |
53 # This is the dictionary that the buildmaster pays attention to. We also use | |
54 # a shorter alias to save typing. | |
55 c = BuildmasterConfig = {} | |
56 | |
57 | |
58 ####### CHANGESOURCES | |
59 | |
60 # the 'change_source' list tells the buildmaster how it should find out about | |
61 # source code changes. Any class which implements IChangeSource can be added | |
62 # to this list: there are several in buildbot/changes/*.py to choose from. | |
63 def NativeClientTreeFileSplitter(path): | |
64 projects = ['native_client'] | |
65 for p in projects: | |
66 if path.startswith(p + '/'): | |
67 return (p, path[len(p)+1:]) | |
68 return None | |
69 | |
70 # Polls config.Master.nacl_trunk_url for changes | |
71 trunk_poller = svnpoller.SVNPoller( | |
72 svnurl=config.Master.nacl_trunk_url + '/src', | |
73 split_file=NativeClientTreeFileSplitter, | |
74 pollinterval=10) | |
75 | |
76 c['change_source'] = [trunk_poller] | |
77 | |
78 | |
79 ####### BUILDERS | |
80 | |
81 # buildbot/process/factory.py provides several BuildFactory classes you can | |
82 # start with, which implement build processes for common targets (GNU | |
83 # autoconf projects, CPAN perl modules, etc). The factory.BuildFactory is the | |
84 # base class, and is configured with a series of BuildSteps. When the build | |
85 # is run, the appropriate buildslave is told to execute each Step in turn. | |
86 | |
87 # the first BuildStep is typically responsible for obtaining a copy of the | |
88 # sources. There are source-obtaining Steps in buildbot/process/step.py for | |
89 # CVS, SVN, and others. | |
90 | |
91 | |
92 # ---------------------------------------------------------------------------- | |
93 # FACTORIES | |
94 | |
95 m_win32 = nacl_factory.NativeClientFactory( | |
96 'native_client', 'win32', use_supplement=True) | |
97 m_win64 = nacl_factory.NativeClientFactory( | |
98 'native_client', 'win64', use_supplement=True) | |
99 m_linux = nacl_factory.NativeClientFactory( | |
100 'native_client', 'linux2', use_supplement=True) | |
101 m_mac = nacl_factory.NativeClientFactory( | |
102 'native_client', 'darwin', use_supplement=True) | |
103 m_arm = nacl_factory.NativeClientFactory( | |
104 'native_client', 'arm', use_supplement=True) | |
105 m_arm_tester = nacl_factory.NativeClientFactory( | |
106 'native_client', 'arm', use_supplement=True) | |
107 | |
108 # Some shortcut to simplify the code below. | |
109 F_WIN32 = m_win32.NativeClientFactory | |
110 F_WIN64 = m_win64.NativeClientFactory | |
111 F_LINUX = m_linux.NativeClientFactory | |
112 F_MAC = m_mac.NativeClientFactory | |
113 F_ARM = m_arm.NativeClientFactory | |
114 | |
115 F_LINUX_GLIBC = m_linux.ModularBuildFactory | |
116 | |
117 F_LINUX_ANNO = m_linux.AnnotatedFactory | |
118 | |
119 | |
120 # The identifier of the factory is the build configuration. If two factories | |
121 # are using the same build configuration, they should have the same identifier. | |
122 | |
123 # BuilderTesters using a custom build configuration. | |
124 factories = [] | |
125 # XP | |
126 for mode in ('dbg', 'opt'): | |
127 name = 'xp-m32-n32-%s' % mode | |
128 factories.append([name, '1Windows', F_WIN32(name, clobber=True, | |
129 target='%s-win,nacl,doc' % mode, | |
130 tests=['nacl_small_tests', | |
131 'nacl_medium_tests', | |
132 'nacl_large_tests'], | |
133 options=nacl_factory.win_m32_n32_options, | |
134 factory_properties={'archive_build': False})]) | |
135 # Vista64 | |
136 for mode in ('dbg', 'opt'): | |
137 name = 'vista64-m64-n64-%s' % mode | |
138 factories.append([name, '1Windows|closer', F_WIN64(name, clobber=True, | |
139 target='%s-win,nacl,doc' % mode, | |
140 tests=[ | |
141 'nacl_small_tests', | |
142 'nacl_medium_tests', | |
143 'nacl_large_tests', | |
144 'nacl_trigger_win7atom64_hw_%s' % mode | |
145 ], | |
146 options=nacl_factory.win_m64_n64_options, | |
147 factory_properties={ | |
148 'archive_build': True, | |
149 'archive_src': 'native_client/vista64.tgz', | |
150 'archive_dst_base': 'between_builders', | |
151 'archive_dst': 'vista64_%s.tgz' % mode, | |
152 })]) | |
153 # Win7 on Atom64 | |
154 for mode in ('dbg', 'opt'): | |
155 name = 'win7atom64-m64-n64-test-%s' % mode | |
156 factories.append([name, '1Windows|closer', F_WIN64(name, clobber=True, | |
157 target='%s-win,nacl,doc' % mode, | |
158 tests=['nacl_small_tests', | |
159 'nacl_medium_tests', | |
160 'nacl_large_tests'], | |
161 options=nacl_factory.win_m64_n64_tester_options, | |
162 slave_type='Tester', | |
163 factory_properties={ | |
164 'archive_build': False, | |
165 'archive_url': ( | |
166 'http://chrome-web.jail.google.com/buildbot/nacl_archive/' | |
167 'between_builders/vista64_%s.tgz' % mode), | |
168 })]) | |
169 # Mac | |
170 for mode in ('dbg', 'opt'): | |
171 name = 'mac-m32-n32-%s' % mode | |
172 factories.append([name, '2Mac', F_MAC(name, clobber=True, | |
173 target='%s-mac,nacl,doc' % mode, | |
174 tests=['nacl_small_tests', | |
175 'nacl_medium_tests', | |
176 'nacl_large_tests', | |
177 'nacl_selenium'], | |
178 options=nacl_factory.generic_m32_n32_options, | |
179 factory_properties={'archive_build': False})]) | |
180 # Linux | |
181 for ver in ('hardy', 'lucid'): | |
182 cat_ver = {'hardy': '3Hardy', 'lucid': '4Lucid'}[ver] | |
183 # m32-n32 | |
184 for b in ('32', '64'): | |
185 for mode in ('dbg', 'opt'): | |
186 name = '%s%s-m32-n32-%s' % (ver, b, mode) | |
187 tests=['nacl_small_tests', | |
188 'nacl_medium_tests', | |
189 'nacl_large_tests', | |
190 'nacl_selenium'] | |
191 factories.append([name, cat_ver, F_LINUX(name, clobber=True, | |
192 target='%s-linux,nacl,doc' % mode, | |
193 tests=tests, | |
194 options=nacl_factory.generic_m32_n32_options, | |
195 factory_properties={'archive_build': False})]) | |
196 # m64-n64 | |
197 for mode in ('dbg', 'opt'): | |
198 name = '%s64-m64-n64-%s' % (ver, mode) | |
199 if ver == 'hardy': | |
200 options=nacl_factory.hardy64_m64_n64_options | |
201 else: | |
202 options=nacl_factory.generic_m64_n64_options | |
203 factories.append([name, cat_ver, F_LINUX(name, clobber=True, | |
204 target='%s-linux,nacl,doc' % mode, | |
205 options=options, | |
206 tests=['nacl_small_tests', | |
207 'nacl_medium_tests', | |
208 'nacl_large_tests'], | |
209 factory_properties={ | |
210 'archive_build': False, | |
211 'gclient_env': {'GYP_DEFINES': 'target_arch=x64'}, | |
212 })]) | |
213 # ARM | |
214 for mode in ('dbg', 'opt'): | |
215 name = 'hardy64-marm-narm-%s' % mode | |
216 factories.append([name, '5Arm', F_ARM(name, clobber=True, | |
217 target='%s-linux,nacl' % mode, | |
218 tests=[ | |
219 'nacl_small_tests', | |
220 'nacl_medium_tests', | |
221 'nacl_large_tests', | |
222 'nacl_trigger_arm_hw_%s' % mode | |
223 ], | |
224 options=nacl_factory.linux_marm_narm_options[mode], | |
225 factory_properties={ | |
226 'archive_build': True, | |
227 'archive_src': 'native_client/arm.tgz', | |
228 'archive_dst_base': 'between_builders', | |
229 'archive_dst': 'arm_%s.tgz' % mode, | |
230 })]) | |
231 | |
232 # Arm board tests | |
233 for mode in ('dbg', 'opt'): | |
234 name = 'arm-marm-narm-test-%s' % mode | |
235 factories.append([name, '5Arm', F_ARM(name, clobber=True, | |
236 target='%s-linux,nacl' % mode, | |
237 tests=[ | |
238 'nacl_small_tests', | |
239 'nacl_medium_tests', | |
240 'nacl_large_tests', | |
241 'nacl_selenium', | |
242 'nacl_arm_hw', | |
243 ], | |
244 options=nacl_factory.linux_marm_narm_options['%s-arm' % mode], | |
245 slave_type='Tester', | |
246 factory_properties={ | |
247 'archive_build': False, | |
248 'archive_url': ('http://chrome-web/buildbot/nacl_archive/' | |
249 'between_builders/arm_%s.tgz' % mode) | |
250 }, | |
251 )]) | |
252 | |
253 # Valgrind | |
254 factories.append(['karmic64-valgrind', '6Other|closer', F_LINUX( | |
255 'karmic64-valgrind', clobber=True, | |
256 target='dbg-linux,nacl', | |
257 options=nacl_factory.generic_m64_n64_options, | |
258 tests=['nacl_valgrind'])]) | |
259 | |
260 # SPEC | |
261 factories.append(['lucid64-spec-arm', '6Other|closer', | |
262 F_LINUX_ANNO('lucid64-spec-arm', | |
263 './tests/spec2k/bot_spec.sh 1 ~/cpu2000-redhat64-ia32')]) | |
264 factories.append(['lucid64-spec-x86', '6Other|closer', | |
265 F_LINUX_ANNO('lucid64-spec-x86', | |
266 './tests/spec2k/bot_spec.sh 2 ~/cpu2000-redhat64-ia32', | |
267 factory_properties={ | |
268 'test_name': 'spec2k', | |
269 'perf_id': 'nacl-lucid64-spec-x86', | |
270 'show_perf_results': True, | |
271 })]) | |
272 factories.append(['lucid64-pnacl-translator', '6Other|closer', | |
273 F_LINUX_ANNO('lucid64-pnacl-translator', | |
274 './tests/spec2k/bot_spec.sh 3 ~/cpu2000-redhat64-ia32')]) | |
275 | |
276 # Coverage | |
277 name = 'mac-m32-n32-coverage' | |
278 factories.append([name, '7Coverage|closer', F_MAC(name, clobber=True, | |
279 target='coverage-mac,nacl,doc', | |
280 tests=['nacl_coverage'], | |
281 options=nacl_factory.generic_m32_n32_options, | |
282 factory_properties={ | |
283 'archive_build': False, | |
284 'archive_coverage': 'coverage-mac-x86-32', | |
285 })]) | |
286 | |
287 name = 'hardy64-m32-n32-coverage' | |
288 factories.append([name, '7Coverage|closer', F_LINUX(name, clobber=True, | |
289 target='coverage-linux,nacl,doc', | |
290 tests=['nacl_coverage'], | |
291 options=nacl_factory.generic_m32_n32_options, | |
292 factory_properties={ | |
293 'archive_build': False, | |
294 'archive_coverage': 'coverage-linux-x86-32', | |
295 })]) | |
296 | |
297 name = 'hardy64-m64-n64-coverage' | |
298 factories.append([name, '7Coverage|closer', F_LINUX(name, clobber=True, | |
299 target='coverage-linux,nacl,doc', | |
300 tests=['nacl_coverage'], | |
301 options=nacl_factory.generic_m64_n64_options, | |
302 factory_properties={ | |
303 'archive_build': False, | |
304 'archive_coverage': 'coverage-linux-x86-64', | |
305 })]) | |
306 | |
307 name = 'hardy64-marm-narm-coverage' | |
308 factories.append([name, '7Coverage|closer', F_ARM(name, clobber=True, | |
309 target='coverage-linux,nacl,doc', | |
310 tests=['nacl_coverage'], | |
311 options=nacl_factory.linux_marm_narm_options['dbg'], | |
312 factory_properties={ | |
313 'archive_build': False, | |
314 'archive_coverage': 'coverage-linux-arm', | |
315 })]) | |
316 | |
317 name = 'xp-m32-n32-coverage' | |
318 factories.append([name, '7Coverage|closer', F_WIN32(name, clobber=True, | |
319 target='coverage-win,nacl,doc', | |
320 tests=['nacl_coverage'], | |
321 options=nacl_factory.win_m32_n32_options, | |
322 factory_properties={ | |
323 'archive_build': False, | |
324 'archive_coverage': 'coverage-win-x86-32', | |
325 })]) | |
326 | |
327 | |
328 ####### SCHEDULERS | |
329 ## configure the Schedulers | |
330 # Main scheduler for all changes in trunk. | |
331 primary_builders = [] | |
332 for f in factories: | |
333 if f[0] not in [ | |
334 'win7atom64-m64-n64-test-dbg', | |
335 'win7atom64-m64-n64-test-opt', | |
336 'arm-marm-narm-test-dbg', | |
337 'arm-marm-narm-test-opt', | |
338 ]: | |
339 primary_builders.append(f[0]) | |
340 s_nacl = Scheduler( | |
341 name='nacl', | |
342 branch='native_client', | |
343 treeStableTimer=60, | |
344 builderNames=primary_builders, | |
345 ) | |
346 | |
347 s_win7atom64_dbg_hw_tests = Triggerable( | |
348 name='win7atom64_dbg_hw_tests', | |
349 builderNames=['win7atom64-m64-n64-test-dbg']) | |
350 s_win7atom64_opt_hw_tests = Triggerable( | |
351 name='win7atom64_opt_hw_tests', | |
352 builderNames=['win7atom64-m64-n64-test-opt']) | |
353 s_arm_dbg_hw_tests = Triggerable(name='arm_dbg_hw_tests', | |
354 builderNames=['arm-marm-narm-test-dbg']) | |
355 s_arm_opt_hw_tests = Triggerable(name='arm_opt_hw_tests', | |
356 builderNames=['arm-marm-narm-test-opt']) | |
357 | |
358 c['schedulers'] = [ | |
359 s_nacl, | |
360 s_win7atom64_dbg_hw_tests, | |
361 s_win7atom64_opt_hw_tests, | |
362 s_arm_dbg_hw_tests, | |
363 s_arm_opt_hw_tests, | |
364 ] | |
365 | |
366 | |
367 # Setup a per slave lock to prevent more than one thing running at once on | |
368 # a single slave. | |
369 slave_lock = locks.SlaveLock('overload_lock', maxCount=1) | |
370 | |
371 | |
372 | |
373 # ---------------------------------------------------------------------------- | |
374 # BUILDER DEFINITIONS | |
375 | |
376 # The 'builders' list defines the Builders. Each one is configured with a | |
377 # dictionary, using the following keys: | |
378 # name (required): the name used to describe this bilder | |
379 # slavename (required): which slave to use, must appear in c['slaves'] | |
380 # builddir (required): which subdirectory to run the builder in | |
381 # factory (required): a BuildFactory to define how the build is run | |
382 # periodicBuildTime (optional): if set, force a build every N seconds | |
383 # category (optional): it is not used in the normal 'buildbot' meaning. It is | |
384 # used by gatekeeper to determine which steps it should | |
385 # look for to close the tree. | |
386 # | |
387 | |
388 def AutoReboot(builder): | |
389 return builder not in [ | |
390 'lucid64-pnacl-translator', | |
391 'lucid64-spec-arm', | |
392 'lucid64-spec-x86', | |
393 'arm-marm-narm-test-dbg', | |
394 'arm-marm-narm-test-opt', | |
395 ] | |
396 | |
397 | |
398 c['builders'] = [] | |
399 slaves = slaves_list.SlavesList('slaves.cfg', 'NativeClient') | |
400 for f in factories: | |
401 c['builders'].append({ | |
402 'name': f[0], | |
403 'slavenames': slaves.GetSlavesName(builder=f[0]), | |
404 'builddir': f[0], | |
405 'factory': f[2], | |
406 'category': '%s' % f[1], | |
407 'locks': [slave_lock], | |
408 'auto_reboot': AutoReboot(f[0]), | |
409 }) | |
410 | |
411 | |
412 ####### BUILDSLAVES | |
413 | |
414 # The 'slaves' list defines the set of allowable buildslaves. List all the | |
415 # slaves registered to a builder. Remove dupes. | |
416 c['slaves'] = master_utils.AutoSetupSlaves(c['builders'], | |
417 config.Master.GetBotPassword()) | |
418 | |
419 # Make sure everything works together. | |
420 master_utils.VerifySetup(c, slaves) | |
421 | |
422 | |
423 ####### STATUS TARGETS | |
424 | |
425 # Adds common status and tools to this master. | |
426 master_utils.AutoSetupMaster(c, ActiveMaster) | |
427 | |
428 # Add more. | |
429 | |
430 if TREE_GATE_KEEPER: | |
431 import gatekeeper | |
432 # This is the list of the builder categories and the corresponding critical | |
433 # steps. If one critical step fails, gatekeeper will close the tree | |
434 # automatically. | |
435 categories_steps = { | |
436 '': [ | |
437 'update scripts', 'update', | |
438 'clobber', 'clobber_packages', | |
439 ], | |
440 'info': [], | |
441 'closer': [ | |
442 'update scripts', 'update', | |
443 'clobber', 'clobber_packages', 'precompile', 'scons_compile', | |
444 'gyp_compile', 'gyp_tests', 'build_packages', | |
445 'cooking_tarball', 'selenium', | |
446 'small_tests', 'medium_tests', 'large_tests', | |
447 'hand_tests', 'smoke_tests', | |
448 'backup_plugin', 'install_plugin', 'start_vncserver', | |
449 'stop_vncserver', 'restore_plugin', | |
450 'archived_build', 'extract_archive', 'setting_acls', | |
451 ], | |
452 } | |
453 exclusions = { } | |
454 forgiving_steps = ['update scripts', 'update', 'svnkill', 'taskkill', | |
455 'archived_build', 'extract_archive', 'setting_acls'], | |
456 c['status'].append(gatekeeper.GateKeeper( | |
457 fromaddr=ActiveMaster.from_address, | |
458 categories_steps=categories_steps, | |
459 exclusions=exclusions, | |
460 relayhost=config.Master.smtp, | |
461 subject='buildbot %(result)s in %(projectName)s on %(builder)s, ' | |
462 'revision %(revision)s', | |
463 extraRecipients=ActiveMaster.tree_closing_notification_recipients, | |
464 tree_status_url=ActiveMaster.tree_status_url, | |
465 lookup='google.com', | |
466 forgiving_steps=forgiving_steps)) | |
467 | |
468 if GOOD_REVISIONS: | |
469 import goodrevisions | |
470 # This is the list of builders with their respective list of critical steps | |
471 # that all need to succeed to mark a revision as successful. A single failure | |
472 # in any of the steps of any of the builders will mark the revision as failed. | |
473 tcb_steps = [ | |
474 'update', | |
475 'gyp_compile', | |
476 'gyp_tests', | |
477 'scons_compile', | |
478 'small_tests', | |
479 'medium_tests', | |
480 'large_tests', | |
481 ] | |
482 coverage_steps = [ | |
483 'update', | |
484 'gyp_compile', | |
485 'gyp_tests', | |
486 'scons_compile', | |
487 'coverage', | |
488 ] | |
489 good_revs = {} | |
490 for f in factories: | |
491 name = f[0] | |
492 if (name.endswith('-dbg') or name.endswith('-opt')) and 'test' not in name: | |
493 if (('mac' in name or 'lucid' in name or 'hardy' in name) and | |
494 'n32' in name and 'arm' not in name): | |
495 good_revs[name] = tcb_steps + ['selenium'] | |
496 else: | |
497 good_revs[name] = tcb_steps | |
498 elif name.endswith('-coverage'): | |
499 good_revs[name] = coverage_steps | |
500 c['status'].append(goodrevisions.GoodRevisions( | |
501 good_revision_steps=good_revs, | |
502 store_revisions_url=ActiveMaster.store_revisions_url)) | |
503 | |
504 | |
505 ####### PROJECT IDENTITY | |
506 | |
507 # Buildbot master url: | |
508 c['buildbotURL'] = 'http://buildbot.jail.google.com/buildbot/nacl/' | |
OLD | NEW |