| 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 |