[Findit] fix bug when display confidence score on SoM.

appengine/findit/findit_api.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.
 
 """This module is to provide Findit service APIs through Cloud Endpoints:
 
 Current APIs include:
 1. Analysis of compile/test failures in Chromium waterfalls.
    Analyzes failures and detects suspected CLs.
 2. Analysis of flakes on Commit Queue.
@@ skipping 141 matching lines @@
       queue_name=constants.WATERFALL_FLAKE_ANALYSIS_REQUEST_QUEUE)
 
 
 # Create a Cloud Endpoints API.
 # https://cloud.google.com/appengine/docs/python/endpoints/create_api
 @endpoints.api(name='findit', version='v1', description='FindIt API')
 class FindItApi(remote.Service):
   """FindIt API v1."""
 
   def _GetConfidenceAndApproachForCL(
-      self, repo_name, revision, confidences, build, first_failure):
+      self, repo_name, revision, confidences, build, reference_build_key):
     cl = WfSuspectedCL.Get(repo_name, revision)
     if not cl:
       return None, None
 
     master_name = buildbot.GetMasterNameFromUrl(build.master_url)
     builder_name = build.builder_name
     current_build = build.build_number
 
     # If the CL is found by a try job, only the first failure will be recorded.
     # So we might need to go to the first failure to get CL information.
     build_info = cl.GetBuildInfo(master_name, builder_name, current_build)
-    first_build_info = cl.GetBuildInfo(master_name, builder_name, first_failure)
+    first_build_info = cl.GetBuildInfo(
+        *build_util.GetBuildInfoFromId(reference_build_key))
     return suspected_cl_util.GetSuspectedCLConfidenceScoreAndApproach(
         confidences, build_info, first_build_info)
 
   def _GenerateBuildFailureAnalysisResult(
       self, build, suspected_cls_in_result, step_name, first_failure, test_name,
-      analysis_approach, confidences, try_job_status, is_flaky_test):
+      analysis_approach, confidences, try_job_status, is_flaky_test,
+      reference_build_key):
 
     suspected_cls = []
     for suspected_cl in suspected_cls_in_result:
       repo_name = suspected_cl['repo_name']
       revision = suspected_cl['revision']
       commit_position = suspected_cl['commit_position']
       confidence, cl_approach = self._GetConfidenceAndApproachForCL(
-          repo_name, revision, confidences, build, first_failure)
+          repo_name, revision, confidences, build, reference_build_key)
       if cl_approach:
         cl_approach = (
           _AnalysisApproach.HEURISTIC if
           cl_approach == analysis_approach_type.HEURISTIC else
           _AnalysisApproach.TRY_JOB)
       else:
         cl_approach = analysis_approach
 
       suspected_cls.append(_SuspectedCL(
           repo_name=repo_name, revision=revision,
@@ skipping 54 matching lines @@
 
   def _CheckIsFlaky(self, swarming_task, test_name):
     """Checks if the test is flaky."""
     if not swarming_task or not swarming_task.classified_tests:
       return False
 
     return test_name in swarming_task.classified_tests.get('flaky_tests', [])
 
   def _PopulateResult(
       self, results, build, build_failure_type,heuristic_result, step_name,
-      confidences, swarming_task, try_job, test_name=None):
+      confidences, reference_build_key, swarming_task, try_job, test_name=None):
     """Appends an analysis result for the given step or test.
 
     Try-job results are always given priority over heuristic results.
     """
     # Default to heuristic analysis.
     suspected_cls = heuristic_result['suspected_cls']
     analysis_approach = _AnalysisApproach.HEURISTIC
 
     # Check if the test is flaky.
     is_flaky_test = self._CheckIsFlaky(swarming_task, test_name)
 
     if is_flaky_test:
       suspected_cls = []
       try_job_status = _TryJobStatus.FINISHED  # There will be no try job.
     else:
       # Check analysis result from try-job.
       try_job_status, culprit = self._GetStatusAndCulpritFromTryJob(
           try_job, swarming_task, build_failure_type, step_name,
           test_name=test_name)
       if culprit:
         suspected_cls = [culprit]
         analysis_approach = _AnalysisApproach.TRY_JOB
     if (not is_flaky_test and not suspected_cls and
         not try_job_status == _TryJobStatus.RUNNING):
       return
 
     results.append(self._GenerateBuildFailureAnalysisResult(
         build, suspected_cls, step_name, heuristic_result['first_failure'],
         test_name, analysis_approach, confidences, try_job_status,
-        is_flaky_test))
+        is_flaky_test, reference_build_key))
 
   def _GetAllSwarmingTasks(self, failure_result_map):
     """Returns all swarming tasks related to one build.
 
     Args:
       A dict to map each step/test with the key to the build when it failed the
       first time.
       {
           'step1': 'm/b/1',
           'step2': {
@@ skipping 63 matching lines @@
         for task_key in step_map.values():
           if not try_jobs.get(task_key):
             try_jobs[task_key] = WfTryJob.Get(*task_key.split('/'))
 
     return try_jobs
 
   def _GetSwarmingTaskAndTryJobForFailure(
       self, step_name, test_name, failure_result_map, swarming_tasks, try_jobs):
     """Gets swarming task and try job for the specific step/test."""
     if not failure_result_map:
-      return None, None
+      return None, None, None
 
     if test_name:
       try_job_key = failure_result_map.get(step_name, {}).get(test_name)
     else:
       try_job_key = failure_result_map.get(step_name)
 
     # Gets the swarming task for the test.
     swarming_task = swarming_tasks.get(step_name, {}).get(try_job_key)
 
     # Get the try job for the step/test.
     try_job = try_jobs.get(try_job_key)
 
-    return swarming_task, try_job
+    return try_job_key, swarming_task, try_job
 
   def _GenerateResultsForBuild(
       self, build, heuristic_analysis, results, confidences):
 
     swarming_tasks = self._GetAllSwarmingTasks(
         heuristic_analysis.failure_result_map)
     try_jobs = self._GetAllTryJobs(heuristic_analysis.failure_result_map)
 
     for failure in heuristic_analysis.result['failures']:
       step_name = failure['step_name']
       if failure.get('tests'):  # Test-level analysis.
         for test in failure['tests']:
           test_name = test['test_name']
-          swarming_task, try_job = self._GetSwarmingTaskAndTryJobForFailure(
-              step_name, test_name, heuristic_analysis.failure_result_map,
-              swarming_tasks, try_jobs)
+          reference_build_key, swarming_task, try_job = (
+              self._GetSwarmingTaskAndTryJobForFailure(
+                  step_name, test_name, heuristic_analysis.failure_result_map,
+                  swarming_tasks, try_jobs))
 
           self._PopulateResult(
               results, build, heuristic_analysis.failure_type, test,
-              step_name, confidences, swarming_task, try_job,
-              test_name=test_name)
+              step_name, confidences, reference_build_key, swarming_task,
+              try_job, test_name=test_name)
       else:
-        swarming_task, try_job = self._GetSwarmingTaskAndTryJobForFailure(
-            step_name, None, heuristic_analysis.failure_result_map,
-            swarming_tasks, try_jobs)
+        reference_build_key, swarming_task, try_job = (
+            self._GetSwarmingTaskAndTryJobForFailure(
+                step_name, None, heuristic_analysis.failure_result_map,
+                swarming_tasks, try_jobs))
         self._PopulateResult(
             results, build, heuristic_analysis.failure_type, failure,
-            step_name, confidences, swarming_task, try_job)
+            step_name, confidences, reference_build_key, swarming_task, try_job)
 
   @endpoints.method(
       _BuildFailureCollection, _BuildFailureAnalysisResultCollection,
       path='buildfailure', name='buildfailure')
   def AnalyzeBuildFailures(self, request):
     """Returns analysis results for the given build failures in the request.
 
     Analysis of build failures will be triggered automatically on demand.
 
     Args:
@@ skipping 73 matching lines @@
 
     try:
       _AsyncProcessFlakeReport(flake_analysis_request, user_email, is_admin)
       queued = True
     except Exception:
       # Ignore the report when fail to queue it for async processing.
       queued = False
       logging.exception('Failed to queue flake report for async processing')
 
     return _FlakeAnalysis(queued=queued)