[Findit] Adding logic to force try jobs regardless of bailout or previous results

appengine/findit/handlers/build_failure.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.
 
 from collections import defaultdict
-import copy
 from datetime import datetime
-import logging
-import os
 
 from google.appengine.api import users
 
 from common import constants
 from common.base_handler import BaseHandler
 from common.base_handler import Permission
 from common.waterfall import failure_type
 from handlers import handlers_util
 from handlers import result_status
 from handlers.result_status import NO_TRY_JOB_REASON_MAP
@@ skipping 120 matching lines @@
           'last_pass': test_result.get('last_pass'),
           'supported': supported,
           'tests': group['tests'],
           'suspected_cls': group['suspected_cls']
       }
       organized_suspected_cls.append(shared_result)
 
   return organized_results
 
 
-def _GetAnalysisResultWithTryJobInfo(
-    organized_results, master_name, builder_name, build_number):
+def _GetAnalysisResultWithTryJobInfo(show_debug_info, organized_results,
+                                     master_name, builder_name, build_number):
   """Reorganizes analysis result and try job result by step_name and culprit.
 
   Returns:
     update_result (dict): A dict of classified results.
 
     The format for those dicts are as below:
     {
         # A dict of results that contains both
         # heuristic analysis results and try job results.
         'reliable_failures': {
@@ skipping 36 matching lines @@
         # such as non-swarming tests or swarming rerun failed.
         'unclassified_failures': {...}
     }
   """
   updated_results = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
 
   if not organized_results:
     return updated_results
 
   try_job_info = handlers_util.GetAllTryJobResults(
-      master_name, builder_name, build_number)
+      master_name, builder_name, build_number, show_debug_info)
+
   if not try_job_info:
     return updated_results
 
   for step_name, try_jobs in try_job_info.iteritems():
     try_jobs = try_jobs['try_jobs']
     step_heuristic_results = organized_results[step_name]
     step_updated_results = updated_results[step_name]['results']
 
     # Finds out try job result index and heuristic result index for each test.
     test_result_map = defaultdict(lambda: defaultdict(int))
@@ skipping 27 matching lines @@
           'try_job': try_job_result,
           'heuristic_analysis': {
               'suspected_cls': heuristic_result['suspected_cls']
           },
           'tests': tests if tests != [NON_SWARMING] else [],
           'first_failure': heuristic_result['first_failure'],
           'last_pass': heuristic_result['last_pass'],
           'supported': heuristic_result['supported']
       }
 
-      if ('status' not in try_job_result or
-          try_job_result['status'] in NO_TRY_JOB_REASON_MAP.values()):
+      if (('status' not in try_job_result or
+           try_job_result['status'] in NO_TRY_JOB_REASON_MAP.values()) or
+          show_debug_info):
         # There is no try job info but only heuristic result.
         try_job_result['status'] = try_job_result.get(
             'status', result_status.UNKNOWN)
         step_updated_results['unclassified_failures'].append(final_result)
       elif try_job_result['status'] == result_status.FLAKY:
         step_updated_results['flaky_failures'].append(final_result)
       else:
         step_updated_results['reliable_failures'].append(final_result)
 
   return updated_results
 
 
 class BuildFailure(BaseHandler):
   PERMISSION_LEVEL = Permission.ANYONE
 
   def _ShowDebugInfo(self):
     # Show debug info only if the app is run locally during development, if the
     # currently logged-in user is an admin, or if it is explicitly requested
     # with parameter 'debug=1'.
-    return (
-            users.is_current_user_admin() or self.request.get('debug') == '1')
+    return users.is_current_user_admin() or self.request.get('debug') == '1'
 
   def _ShowTriageHelpButton(self):
     return users.is_current_user_admin()
 
   def _PrepareCommonDataForFailure(self, analysis):
     return {
         'master_name': analysis.master_name,
         'builder_name': analysis.builder_name,
         'build_number': analysis.build_number,
         'pipeline_status_path': analysis.pipeline_status_path,
@@ skipping 18 matching lines @@
       return try_job_data  # pragma: no cover.
 
     referred_build_keys = analysis.failure_result_map[
         constants.COMPILE_STEP_NAME].split('/')
     try_job = WfTryJob.Get(*referred_build_keys)
     if not try_job or not try_job.compile_results:
       return try_job_data  # pragma: no cover.
     result = try_job.compile_results[-1]
 
     try_job_data['status'] = analysis_status.STATUS_TO_DESCRIPTION.get(
-          try_job.status, 'unknown').lower()
+        try_job.status, 'unknown').lower()
     try_job_data['url'] = result.get('url')
     try_job_data['completed'] = try_job.completed
     try_job_data['failed'] = try_job.failed
     try_job_data['culprit'] = result.get(
         'culprit', {}).get(constants.COMPILE_STEP_NAME)
 
     return try_job_data
 
   @staticmethod
   def _PopulateHeuristicDataForCompileFailure(analysis, data):
@@ skipping 10 matching lines @@
   def _PrepareDataForCompileFailure(self, analysis):
     data = self._PrepareCommonDataForFailure(analysis)
 
     # Check result from heuristic analysis.
     self._PopulateHeuristicDataForCompileFailure(analysis, data)
     # Check result from try job.
     data['try_job'] = self._PrepareTryJobDataForCompileFailure(analysis)
 
     return data
 
-  def _PrepareDataForTestFailures(self, analysis, build_info):
+  def _PrepareDataForTestFailures(self, analysis, build_info,
+                                  show_debug_info=False):
     data = self._PrepareCommonDataForFailure(analysis)
     data['status_message_map'] = result_status.STATUS_MESSAGE_MAP
 
     organized_results = _GetOrganizedAnalysisResultBySuspectedCL(
         analysis.result)
     analysis_result = _GetAnalysisResultWithTryJobInfo(
-        organized_results, *build_info)
+        show_debug_info, organized_results, *build_info)
+
     data['analysis_result'] = analysis_result
 
     return data
 
   def HandleGet(self):
     """Triggers analysis of a build failure on demand and return current result.
 
     If the final analysis result is available, set cache-control to 1 day to
     avoid overload by unnecessary and frequent query from clients; otherwise
     set cache-control to 5 seconds to allow repeated query.
@@ skipping 15 matching lines @@
       if not analysis:
         return BaseHandler.CreateError(
             'Master "%s" is not supported yet.' % master_name, 501)
 
     if not analysis:
       # Only allow admin to force a re-run and set the build_completed.
       force = (users.is_current_user_admin() and
                self.request.get('force') == '1')
       build_completed = (users.is_current_user_admin() and
                          self.request.get('build_completed') == '1')
+      force_try_job = (users.is_current_user_admin() and
+                       self.request.get('force_try_job') == '1')
       analysis = build_failure_analysis_pipelines.ScheduleAnalysisIfNeeded(
           master_name, builder_name, build_number,
           build_completed=build_completed, force=force,
+          force_try_job=force_try_job,
           queue_name=constants.WATERFALL_ANALYSIS_QUEUE)
 
     if analysis.failure_type == failure_type.COMPILE:
       return {
-        'template': 'waterfall/compile_failure.html',
-        'data': self._PrepareDataForCompileFailure(analysis),
+          'template': 'waterfall/compile_failure.html',
+          'data': self._PrepareDataForCompileFailure(analysis),
       }
     else:
       return {
-        'template': 'build_failure.html',
-        'data': self._PrepareDataForTestFailures(analysis, build_info),
+          'template': 'build_failure.html',
+          'data': self._PrepareDataForTestFailures(analysis, build_info,
+                                                   self._ShowDebugInfo()),
       }
 
   def HandlePost(self):  # pragma: no cover
     return self.HandleGet()