[Findit] Change the criteria of sending notification to code review.

appengine/findit/waterfall/identify_try_job_culprit_pipeline.py

 # Copyright 2015 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 logging
 
 from google.appengine.ext import ndb
 
 from common.git_repository import GitRepository
@@ skipping 164 matching lines @@
       for failed_test in test_result['failures']:
         # Swarming tests, gets first failed revision for each test.
         if failed_test not in culprit_map[step]['tests']:
           culprit_map[step]['tests'][failed_test] = {
               'revision': revision
           }
 
   return culprit_map, list(failed_revisions)
 
 
-def _NotifyCulprits(master_name, builder_name, build_number, culprits):
+def _GetSuspectedCLFoundByHeuristicForCompile(analysis):
+  """For compile failure, gets the suspected revision found by heuristic."""
+  if not analysis or not analysis.result:
+    return None
+
+  for failure in analysis.result.get('failures', []):
+    if (failure['step_name'].lower() == 'compile' and
+        len(failure['suspected_cls']) == 1):
+      # Based on confidence calculation, suspected_cl found by heuristic for
+      # compile is very likely to be the culprit.
+      # Since the current confidence calculation is for results with single
+      # suspected_cl, we might need to have the same regulation here.
+      return failure['suspected_cls'][0]
+  return None
+
+
+def _GetHeuristicSuspectedCLs(analysis):
+  """Gets revisions of suspected cls found by heuristic approach."""
+  if analysis and analysis.suspected_cls:
+    return [(cl['repo_name'], cl['revision']) for cl in analysis.suspected_cls]
+  return []
+
+
+def _StartSendNotificationPipeline(
+    master_name, builder_name, build_number, repo_name, revision,
+    send_notification_right_now):
+  try:
+    pipeline = SendNotificationForCulpritPipeline(
+        master_name, builder_name, build_number, repo_name, revision,
+        send_notification_right_now)
+    pipeline.start()
+  except Exception:  # pragma: no cover.
+    logging.exception('Failed to notify culprit.')
+
+
+def _NotifyCulprits(master_name, builder_name, build_number, culprits,
+                    heuristic_cls, compile_suspected_cl):
   """Sends notifications to the identified culprits."""
-  try:
-    for culprit in (culprits or {}).itervalues():
-      pipeline = SendNotificationForCulpritPipeline(
+
+  if culprits:
+    # There is a try job result, so check if any of the culprits
+    # was also found by heuristic analysis.
+    for culprit in culprits.itervalues():
+      send_notification_right_now = False
+      send_notification_right_now = (
+          culprit['repo_name'], culprit['revision']) in heuristic_cls
+      _StartSendNotificationPipeline(
           master_name, builder_name, build_number,
-          culprit['repo_name'], culprit['revision'])
-      pipeline.start()
-  except Exception:  # pragma: no cover.
-    logging.exception('Failed to notify culprits.')
+          culprit['repo_name'], culprit['revision'],
+          send_notification_right_now)
+  elif compile_suspected_cl:
+    # A special case where try job didn't find any suspected cls, but
+    # heuristic found a suspected_cl.
+    _StartSendNotificationPipeline(
+        master_name, builder_name, build_number,
+        compile_suspected_cl['repo_name'], compile_suspected_cl['revision'],
+        send_notification_right_now=True)
 
 
 class IdentifyTryJobCulpritPipeline(BasePipeline):
   """A pipeline to identify culprit CL info based on try job compile results."""
 
   def _GetCulpritInfo(self, failed_revisions):
     """Gets commit_positions and review urls for revisions."""
     culprits = {}
     # TODO(lijeffrey): remove hard-coded 'chromium' when DEPS file parsing is
     # supported.
@@ skipping 110 matching lines @@
         else:  # pragma: no cover
           result_to_update.append(result)
       try_job_result.status = analysis_status.COMPLETED
       try_job_result.put()
 
     @ndb.transactional
     def UpdateWfAnalysisWithTryJobResult():
       if not culprits:
         return
 
+      analysis = WfAnalysis.Get(master_name, builder_name, build_number)
       # Update analysis result and suspected CLs with results of this try job if
       # culprits were found.
-      analysis = WfAnalysis.Get(master_name, builder_name, build_number)
       updated_result_status = _GetResultAnalysisStatus(analysis, result)
       updated_suspected_cls = _GetSuspectedCLs(analysis, result)
 
       if (analysis.result_status != updated_result_status or
           analysis.suspected_cls != updated_suspected_cls):
         analysis.result_status = updated_result_status
         analysis.suspected_cls = updated_suspected_cls
         analysis.put()
 
     # Store try-job results.
     UpdateTryJobResult()
+
+    # Saves cls found by heuristic approach for later use.
+    # This part must be before UpdateWfAnalysisWithTryJobResult().
+    analysis = WfAnalysis.Get(master_name, builder_name, build_number)
+    heuristic_cls = _GetHeuristicSuspectedCLs(analysis)
+    compile_suspected_cl = (
+        _GetSuspectedCLFoundByHeuristicForCompile(analysis)
+        if try_job_type == failure_type.COMPILE else None)
+
     # Add try-job results to WfAnalysis.
     UpdateWfAnalysisWithTryJobResult()
 
-    _NotifyCulprits(master_name, builder_name, build_number, culprits)
-    return result.get('culprit') if result else None
+    _NotifyCulprits(master_name, builder_name, build_number, culprits,
+                    heuristic_cls, compile_suspected_cl)
+    return result.get('culprit') if result else None