Allow a single trybot to mirror multiple waterfall bots.

scripts/slave/recipes/chromium_trybot.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import collections
 
 from recipe_engine.types import freeze
 
 DEPS = [
   'amp',
@@ skipping 181 matching lines @@
                     for test in tests
                     for x in test.compile_targets(api)))
 
 
 def is_source_file(api, filepath):
   """Returns true iff the file is a source file."""
   _, ext = api.path.splitext(filepath)
   return ext in ['.c', '.cc', '.cpp', '.h', '.java', '.mm']
 
 def _RunStepsInternal(api):
-  def _get_bot_config(mastername, buildername):
+  # This returns either a single dictionary or list of dictionaries
+  # that contain the 'mastername' and 'buildername' properties. This
+  # is the 'bot_desc' concept rather than the 'bot_config' concept.
+  def _get_bot_desc(mastername, buildername):
     master_dict = api.chromium_tests.trybots.get(mastername, {})
     return master_dict.get('builders', {}).get(buildername)
 
   mastername = api.properties.get('mastername')
   buildername = api.properties.get('buildername')
-  bot_config = _get_bot_config(mastername, buildername)
+  bot_descs = _get_bot_desc(mastername, buildername)
+  # Support the case where a single trybot picks up compile targets
+  # and tests from multiple bots.
+  bot_descs = api.chromium_tests.normalize_bot_descs(bot_descs)
 
   # TODO(sergiyb): This is a temporary hack to run GPU tests on tryserver
   # only. This should be removed when we will convert chromium.gpu waterfall
   # to swarming and be able to replicate the tests to tryserver automatically.
   master = api.properties['mastername']
   builder = api.properties['buildername']
   enable_gpu_tests = builder in CHROMIUM_GPU_DIMENSION_SETS.get(master, {})
 
   api.chromium_tests.configure_build(
-      bot_config['mastername'],
-      bot_config['buildername'],
+      bot_descs,
       override_bot_type='builder_tester')
 
   api.chromium_tests.configure_swarming('chromium', precommit=True)
 
   api.chromium.apply_config('trybot_flavor')
   if enable_gpu_tests:
-    api.chromium.apply_config('archive_gpu_tests')
-    api.chromium.apply_config('chrome_with_codecs')
+    # TODO(kbr): the "optional" flag is only being used during the
+    # transition from the GPU recipe to the Chromium recipe. This
+    # entire if-test will soon be removed.
+    api.chromium.apply_config('archive_gpu_tests', optional=True)
+    api.chromium.apply_config('chrome_with_codecs', optional=True)
 
   if api.properties.get('patch_project') == 'blink':  # pragma: no cover
     raise Exception('CLs which use blink project are not supported. '
                     'Please re-create the CL using fresh checkout after '
                     'the blink merge.')
 
   bot_update_step, bot_db = \
-      api.chromium_tests.prepare_checkout(
-          bot_config['mastername'],
-          bot_config['buildername'])
+      api.chromium_tests.prepare_checkout(bot_descs)
 
-  tests = list(api.chromium_tests.tests_for_builder(
-      bot_config['mastername'],
-      bot_config['buildername'],
-      bot_update_step,
-      bot_db,
-      override_bot_type='builder_tester'))
-  tester = bot_config.get('tester', '')
-  if tester:
-    test_config = bot_db.get_bot_config(bot_config['mastername'], tester)
-    for key, value in test_config.get('swarming_dimensions', {}).iteritems():
-      api.swarming.set_default_dimension(key, value)
+  tests = []
+  for bot_desc in bot_descs:
     tests.extend(api.chromium_tests.tests_for_builder(
-        bot_config['mastername'],
-        tester,
+        bot_desc['mastername'],
+        bot_desc['buildername'],
         bot_update_step,
         bot_db,
         override_bot_type='builder_tester'))
+    tester = bot_desc.get('tester', '')
+    if tester:
+      test_config = bot_db.get_bot_config(bot_desc['mastername'], tester)
+      for key, value in test_config.get('swarming_dimensions', {}).iteritems():
+        api.swarming.set_default_dimension(key, value)
+      tests.extend(api.chromium_tests.tests_for_builder(
+          bot_desc['mastername'],
+          tester,
+          bot_update_step,
+          bot_db,
+          override_bot_type='builder_tester'))
 
   if enable_gpu_tests:
     tests.extend(api.gpu.create_tests(
         bot_update_step.presentation.properties['got_revision'],
         bot_update_step.presentation.properties['got_revision'],
         enable_swarming=True,
         swarming_dimension_sets=CHROMIUM_GPU_DIMENSION_SETS[master][builder]))
 
   affected_files = api.tryserver.get_files_affected_by_patch()
 
@@ skipping 22 matching lines @@
   if add_blink_tests:
     tests.extend([
         api.chromium_tests.steps.GTestTest('blink_heap_unittests'),
         api.chromium_tests.steps.GTestTest('blink_platform_unittests'),
         api.chromium_tests.steps.GTestTest('webkit_unit_tests'),
         api.chromium_tests.steps.GTestTest('wtf_unittests'),
     ])
 
   compile_targets, tests_including_triggered = \
       api.chromium_tests.get_compile_targets_and_tests(
-          bot_config['mastername'],
-          bot_config['buildername'],
+          bot_descs,
           bot_db,
           override_bot_type='builder_tester',
           override_tests=tests)
 
   test_targets = sorted(set(
       all_compile_targets(api, tests + tests_including_triggered)))
   additional_compile_targets = sorted(set(compile_targets) -
                                       set(test_targets))
   test_targets, compile_targets = \
       api.chromium_tests.analyze(affected_files,
                                  test_targets,
                                  additional_compile_targets,
                                  'trybot_analyze_config.json')
 
-  if bot_config.get('analyze_mode') == 'compile':
+  if bot_descs[0].get('analyze_mode') == 'compile':

[Sergey Berezin, 2016/01/12 01:44:23]

nit: this makes the [0]'th configuration "special", supplying extra parameters
for the trybot as a whole. Is this intentional?

[Ken Russell (switch to Gerrit), 2016/01/12 05:35:51]

I didn't understand this code nor the ramifications of making it iterate over
all the bot_descs so leaving it checking the 0'th one seemed safest. I probably
should have added an assert.

Looking more deeply, this zaps all of the tests, and is used only on the
compile-only tryservers. I guess it makes sense to take the union of the
settings in all of the bot_descs.

     tests = []
     tests_including_triggered = []
 
   # Blink tests have to bypass "analyze", see below.
   if compile_targets or add_blink_tests:
     tests = tests_in_compile_targets(api, test_targets, tests)
     tests_including_triggered = tests_in_compile_targets(
         api, test_targets, tests_including_triggered)
 
     # Blink tests are tricky at this moment. We'd like to use "analyze" for
     # everything else. However, there are blink changes that only add or modify
     # layout test files (html etc). This is not recognized by "analyze" as
     # compile dependency. However, the blink tests should still be executed.
     if add_blink_tests:
       blink_tests = [
           api.chromium_tests.steps.ScriptTest(
               'webkit_lint', 'webkit_lint.py', collections.defaultdict(list)),
           api.chromium_tests.steps.ScriptTest(
               'webkit_python_tests', 'webkit_python_tests.py',
               collections.defaultdict(list)),
           api.chromium_tests.steps.BlinkTest(),
       ]
       tests.extend(blink_tests)
       tests_including_triggered.extend(blink_tests)
       for test in blink_tests:
         compile_targets.extend(test.compile_targets(api))
       compile_targets = sorted(set(compile_targets))
 
     api.chromium_tests.compile_specific_targets(
-        bot_config['mastername'],
-        bot_config['buildername'],
+        bot_descs[0]['mastername'],
+        bot_descs[0]['buildername'],
         bot_update_step,
         bot_db,
         compile_targets,
         tests_including_triggered,
         override_bot_type='builder_tester')
   else:
     # Even though the patch doesn't require a compile on this platform,
     # we'd still like to run tests not depending on
     # compiled targets (that's obviously not covered by the
     # 'analyze' step) if any source files change.
@@ skipping 55 matching lines @@
             },
             'chromium': {
                 'exclusions': [],
             },
         })
     )
 
   # While not strictly required for coverage, record expectations for each
   # of the configs so we can see when and how they change.
   for mastername, master_config in api.chromium_tests.trybots.iteritems():
-    for buildername, bot_config in master_config['builders'].iteritems():
+    for buildername, bot_desc in master_config['builders'].iteritems():
       for analyze in ['', '_analyze']:
         test_name = 'full_%s_%s%s' % (_sanitize_nonalpha(mastername),
                                       _sanitize_nonalpha(buildername),
                                       analyze)
+        bot_desc = api.chromium_tests.normalize_bot_descs(bot_desc)
         yield (
           api.test(test_name) +
+          # In the case where a trybot mirrors multiple waterfall
+          # bots, pick up the platform from the first one. (They
+          # should all be identical, anyway.)
           api.chromium_tests.platform(
-              bot_config['mastername'], bot_config['buildername']) +
+              bot_desc[0]['mastername'], bot_desc[0]['buildername']) +
           (api.empty_test_data() if analyze else suppress_analyze()) +
           props(mastername=mastername, buildername=buildername)
         )
 
   # Additional tests for blink trybots.
   blink_trybots = api.chromium_tests.trybots['tryserver.blink']['builders']
   for buildername, bot_config in blink_trybots.iteritems():
     if bot_config.get('analyze_mode') == 'compile':
       continue
 
@@ skipping 635 matching lines @@
                            api.test_utils.canned_test_output(passing=True))
   )
 
   yield (
     api.test('use_v8_patch_on_blink_trybot') +
     props(mastername='tryserver.blink',
           buildername='mac_blink_rel',
           patch_project='v8') +
     api.platform.name('mac')
   )
+
+  # This tests the scenario where one trybot mirrors multiple
+  # waterfall bots. Right now, linux_chromium_rel_ng has the GPU tests
+  # hardwired in. The presence of base_unittests in the output with
+  # the configuration below shows that the mirroring is working
+  # correctly. (Once the bot is switched from the GPU to the Chromium
+  # recipe, the test setup and expectations will be updated -- no
+  # reminder necessary, they'll have to be.)
+  yield (
+    api.test('trybot_mirrors_multiple_waterfall_bots') +
+    api.properties.tryserver(
+      mastername='tryserver.chromium.linux',
+      buildername='linux_chromium_rel_ng',
+      path_config='swarming',
+    ) +
+    api.platform.name('linux') +
+    suppress_analyze() +
+    api.override_step_data('read test spec (chromium.gpu)', api.json.output({
+        'Fake Linux Release (NVIDIA)': {
+            'gtest_tests': ['base_unittests'],
+        },
+    }))
+  )