Add logcats link in builbot page for android swarming tasks

scripts/slave/recipe_modules/chromium_tests/steps.py

 # Copyright 2014 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 datetime
 import re
 import string
 
-
 class Test(object):
   """
   Base class for tests that can be retried after deapplying a previously
   applied patch.
   """
 
   def __init__(self):
     super(Test, self).__init__()
     self._test_runs = {}
 
@@ skipping 414 matching lines @@
     if test['shard_index'] != 0 or test['total_shards'] != 1:
       args.extend(['--test-launcher-shard-index=%d' % test['shard_index'],
                    '--test-launcher-total-shards=%d' % test['total_shards']])
     use_swarming = False
     swarming_shards = 1
     swarming_dimension_sets = None
     swarming_priority = None
     swarming_expiration = None
     swarming_hard_timeout = None
     cipd_packages = None
+    output_links = None
     if enable_swarming:
       swarming_spec = test.get('swarming', {})
       if swarming_spec.get('can_use_on_swarming_builders'):
         use_swarming = True
         swarming_shards = swarming_spec.get('shards', 1)
         swarming_dimension_sets = swarming_spec.get('dimension_sets')
         swarming_priority = swarming_spec.get('priority_adjustment')
         swarming_expiration = swarming_spec.get('expiration')
         swarming_hard_timeout = swarming_spec.get('hard_timeout')
         packages = swarming_spec.get('cipd_packages')
+        output_links = swarming_spec.get('output_links')
         if packages:
           cipd_packages = [(p['location'],
                             p['cipd_package'],
                             p['revision'])
                            for p in packages]
     override_compile_targets = test.get('override_compile_targets', None)
     override_isolate_target = test.get('override_isolate_target', None)
     target_name = str(test['test'])
     name = str(test.get('name', target_name))
     swarming_dimensions = swarming_dimensions or {}
     use_xvfb = test.get('use_xvfb', True)
     if use_swarming and swarming_dimension_sets:
       for dimensions in swarming_dimension_sets:
         # Yield potentially multiple invocations of the same test, on
         # different machine configurations.
         new_dimensions = dict(swarming_dimensions)
         new_dimensions.update(dimensions)
         yield GTestTest(name, args=args, target_name=target_name,
                         flakiness_dash=True,
                         enable_swarming=True,
                         swarming_shards=swarming_shards,
                         swarming_dimensions=new_dimensions,
                         swarming_priority=swarming_priority,
                         swarming_expiration=swarming_expiration,
                         swarming_hard_timeout=swarming_hard_timeout,
                         override_compile_targets=override_compile_targets,
                         override_isolate_target=override_isolate_target,
-                        use_xvfb=use_xvfb, cipd_packages=cipd_packages)
+                        use_xvfb=use_xvfb, cipd_packages=cipd_packages,
+                        output_links=output_links)
     else:
       yield GTestTest(name, args=args, target_name=target_name,
                       flakiness_dash=True,
                       enable_swarming=use_swarming,
                       swarming_dimensions=swarming_dimensions,
                       swarming_shards=swarming_shards,
                       swarming_priority=swarming_priority,
                       swarming_expiration=swarming_expiration,
                       swarming_hard_timeout=swarming_hard_timeout,
                       override_compile_targets=override_compile_targets,
                       override_isolate_target=override_isolate_target,
-                      use_xvfb=use_xvfb, cipd_packages=cipd_packages)
+                      use_xvfb=use_xvfb, cipd_packages=cipd_packages,
+                      output_links=output_links)
 
 
 def generate_instrumentation_test(api, chromium_tests_api, mastername,
                                   buildername, test_spec, bot_update_step,
                                   enable_swarming=False,
                                   swarming_dimensions=None,
                                   scripts_compile_targets=None):
   for test in test_spec.get(buildername, {}).get('instrumentation_tests', []):
     test_name = str(test.get('test'))
     use_swarming = False
@@ skipping 325 matching lines @@
   @property
   def uses_swarming(self):
     return True
 
 
 class SwarmingGTestTest(SwarmingTest):
   def __init__(self, name, args=None, target_name=None, shards=1,
                dimensions=None, tags=None, extra_suffix=None, priority=None,
                expiration=None, hard_timeout=None, upload_test_results=True,
                override_compile_targets=None, override_isolate_target=None,
-               cipd_packages=None):
+               cipd_packages=None, output_links=None):
     super(SwarmingGTestTest, self).__init__(name, dimensions, tags, target_name,
                                             extra_suffix, priority, expiration,
                                             hard_timeout)
     self._args = args or []
     self._shards = shards
     self._upload_test_results = upload_test_results
     self._override_compile_targets = override_compile_targets
     self._override_isolate_target = override_isolate_target
     self._cipd_packages = cipd_packages
+    self._output_links = output_links
 
   def compile_targets(self, api):
     # <X>_run target depends on <X>, and then isolates it invoking isolate.py.
     # It is a convention, not a hard coded rule.
     # Also include name without the _run suffix to help recipes correctly
     # interpret results returned by "analyze".
     if self._override_compile_targets:
       return self._override_compile_targets
 
     if api.chromium.c.TARGET_PLATFORM == 'android':
@@ skipping 46 matching lines @@
 
     return True, gtest_results.failures
 
   def post_run(self, api, suffix, test_filter=None):
     """Waits for launched test to finish and collects the results."""
     try:
       super(SwarmingGTestTest, self).post_run(
           api, suffix,test_filter=test_filter)
     finally:
       step_result = api.step.active_result
+
+      # Populate additional swarming links on buildbot page
+      if self._output_links:
+        for task in self._tasks.values():
+          for test in task.trigger_output['tasks'].values():
+            task_id = test.get('task_id')
+            shard_index = str(test.get('shard_index'))
+            for output in self._output_links:
+              name = output['name']
+              link = output['link']

[ghost stip (do not use), 2016/08/08 20:51:12]

can you move this down so it's just above 931? that way all the name stuff is
together and the link stuff is together as well

+              name = (name.replace('${SHARD_INDEX}', shard_index)).replace(
+                  '${TASK_ID}', task_id)
+              link = ''.join(link)

[ghost stip (do not use), 2016/08/08 20:51:12]

put a comment here on why we're doing this

+              link = (link.replace('${SHARD_INDEX}', shard_index)).replace(
+                  '${TASK_ID}', task_id)
+              step_result.presentation.links[name] = link
+
       # Only upload test results if we have gtest results.
       if (self._upload_test_results and
           hasattr(step_result, 'test_utils') and
           hasattr(step_result.test_utils, 'gtest_results')):
         gtest_results = getattr(step_result.test_utils, 'gtest_results', None)
         if gtest_results and gtest_results.raw:
           parsed_gtest_data = gtest_results.raw
           chrome_revision_cp = api.bot_update.last_returned_properties.get(
               'got_revision_cp', 'x@{#0}')
           chrome_revision = str(api.commit_position.parse_revision(
@@ skipping 223 matching lines @@
       yield LocalIsolatedScriptTest(
           name=name, args=args, target_name=target_name,
           override_compile_targets=override_compile_targets)
 
 
 class GTestTest(Test):
   def __init__(self, name, args=None, target_name=None, enable_swarming=False,
                swarming_shards=1, swarming_dimensions=None, swarming_tags=None,
                swarming_extra_suffix=None, swarming_priority=None,
                swarming_expiration=None, swarming_hard_timeout=None,
-               cipd_packages=None, **runtest_kwargs):
+               cipd_packages=None, output_links=None, **runtest_kwargs):
     super(GTestTest, self).__init__()
     if enable_swarming:
       self._test = SwarmingGTestTest(
           name, args, target_name, swarming_shards, swarming_dimensions,
           swarming_tags, swarming_extra_suffix, swarming_priority,
           swarming_expiration, swarming_hard_timeout,
-          cipd_packages=cipd_packages,
+          cipd_packages=cipd_packages, output_links=output_links,
           override_compile_targets=runtest_kwargs.get(
               'override_compile_targets'),
           override_isolate_target=runtest_kwargs.get(
               'override_isolate_target'))
     else:
       self._test = LocalGTestTest(name, args, target_name, **runtest_kwargs)
 
     self.enable_swarming = enable_swarming
 
   @property
@@ skipping 568 matching lines @@
           args=args)
       api.gsutil.upload(
           temp_output_dir.join(
               '%s-android-chrome.json' % timestamp_string),
           'chromium-annotated-tests', 'android')
 
 GOMA_TESTS = [
   GTestTest('base_unittests'),
   GTestTest('content_unittests'),
 ]