Use buildbucket to assess build failure.

scripts/slave/recipe_modules/auto_bisect/revision_state.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.
 
 """An interface for holding state and result of revisions in a bisect job.
 
 When implementing support for tests other than perf, one should extend this
 class so that the bisect module and recipe can use it.
 
 See perf_revision_state for an example.
 """
 
 import hashlib
 import json
 import math
 import os
 import tempfile
 import re
 import uuid
 
 from . import depot_config
 
 # These relate to how to increase the number of repetitions during re-test
 MINIMUM_SAMPLE_SIZE = 5
 INCREASE_FACTOR = 1.5
-# Buildbot job result codes.
-# See http://docs.buildbot.net/current/developer/results.html
-SUCCESS, WARNINGS, FAILURE, SKIPPED, EXCEPTION = range(5)
 
 class RevisionState(object):
   """Abstracts the state of a single revision on a bisect job."""
 
   # Possible values for the status attribute of RevisionState:
   (
       NEW,  # A revision_state object that has just been initialized.
       BUILDING,  # Requested a build for this revision, waiting for it.
       TESTING,  # A test job for this revision was triggered, waiting for it.
       TESTED,  # The test job completed with non-failing results.
@@ skipping 30 matching lines @@
     self.previous_revision = None
     self.job_name = None
     self.patch_file = None
     self.deps_revision = None
     self.depot_name = depot_name or self.bisector.base_depot
     self.depot = depot_config.DEPOT_DEPS_NAME[self.depot_name]
     self.commit_hash = str(commit_hash)
     self._rev_str = None
     self.base_revision = base_revision
     self.revision_overrides = {}
+    self.build_id = None
     if self.base_revision:
       assert self.base_revision.deps_file_contents
       self.needs_patch = True
       self.revision_overrides[self.depot['src']] = self.commit_hash
       self.deps_patch, self.deps_file_contents = self.bisector.make_deps_patch(
           self.base_revision, self.base_revision.deps_file_contents,
           self.depot, self.commit_hash)
       self.deps_sha = hashlib.sha1(self.deps_patch).hexdigest()
       self.deps_sha_patch = self.bisector.make_deps_sha_file(self.deps_sha)
       self.deps = dict(base_revision.deps)
       self.deps[self.depot_name] = self.commit_hash
     else:
       self.needs_patch = False
     self.build_url = self.bisector.get_platform_gs_prefix() + self._gs_suffix()
     self.values = []
     self.mean_value = None
     self.overall_return_code = None
     self.std_dev = None
     self._test_config = None
-    self.build_number = None
 
     if self.bisector.test_type == 'perf':
       self.repeat_count = MINIMUM_SAMPLE_SIZE
     else:
       self.repeat_count = self.bisector.bisect_config.get(
           'repeat_count', MINIMUM_SAMPLE_SIZE)
 
   @property
   def tested(self):
     return self.status in (RevisionState.TESTED,)
@@ skipping 167 matching lines @@
     """Checks if the revision is already built and archived."""
     if not self.build_archived:
       api = self.bisector.api
       self.build_archived = api.gsutil_file_exists(self.build_url)
 
     if self.bisector.dummy_builds:
       self.build_archived = self.in_progress
 
     return self.build_archived
 
-  def _fetch_build_info(self, base_url, build_number):
-    api = self.bisector.api
-    build_url = '%s/builds/%s?as_text=1' % (base_url, build_number)
-    fetch_result = api.m.url.fetch( build_url, step_name='fetch build details')
-    return json.loads(fetch_result or '{}')
-
   def _is_build_failed(self):
-    api = self.bisector.api
-    current_build = None
-    path = 'json/builders/' + self.bisector.get_builder_bot_for_this_platform()
-    base_url = api.m.properties.get('buildbotURL', 'http://localhost:8041/')
-    base_url += path
-    if self.build_number is None:
-      try:
-        # Get all the current builds.
-        builder_state_url = base_url + '?as_text=1'
-        builder_state = api.m.url.fetch(
-            builder_state_url, step_name='fetch builder state')
-        builder_state = json.loads(builder_state or '{}')
-        for build_number in builder_state.get('cachedBuilds', []):
-          build = self._fetch_build_info(base_url, build_number)
-          # Properties is a list of triples (key, value, source)
-          build_properties = dict([t[:2] for t in build.get('properties', [])])
-          if build_properties.get('build_archive_url') == self.build_url:
-            self.build_number = build_number
-            current_build = build
-            break
-      except (api.m.step.StepFailure, ValueError):  # pragma: no cover
-        # If we cannot get json from buildbot, we cannot determine if a build is
-        # failed, hence we consider it in progress until it times out.
-        return False
-    if self.build_number is None:
-      # The build hasn't started yet, therefore it's not failed.
-      return False
-    if not current_build:
-      current_build = self._fetch_build_info(base_url, self.build_number)
-    return current_build.get('results') in [FAILURE, SKIPPED, EXCEPTION]
+    result = self.bisector.api.m.buildbucket.get_build(
+        self.build_id,
+        step_test_data=lambda: self.bisector.api.m.json.test_api.output_stream(
+            {'results': [
+                {'build': {'result': 'SUCCESS', 'status': 'COMPLETED'}}]}
+        ))
+    return (result.stdout['results'][0]['build']['status'] == 'COMPLETED' and
+            result.stdout['results'][0]['build'].get('result') != 'SUCCESS')
 
   def _results_available(self):
     """Checks if the results for the test job have been uploaded."""
     api = self.bisector.api
     result = api.gsutil_file_exists(self.test_results_url)
     if self.bisector.dummy_builds:
       return self.in_progress
     return result  # pragma: no cover
 
   def _gs_suffix(self):
@@ skipping 87 matching lines @@
                 'build_archive_url': self.build_url,
             },
         },
         'client_operation_id': operation_id
     }
     if self.revision_overrides:
       build_details['parameters']['properties']['deps_revision_overrides'] = \
           self.revision_overrides
 
     try:
-      api.m.buildbucket.put([build_details],
-                            api.m.service_account.get_json_path(
-                                api.SERVICE_ACCOUNT))
+      result = api.m.buildbucket.put(
+          [build_details],
+          api.m.service_account.get_json_path(api.SERVICE_ACCOUNT),
+          step_test_data=lambda: api.m.json.test_api.output_stream(
+              {'results':[{'build':{'id':'1201331270'}}]}))
     except api.m.step.StepFailure:  # pragma: no cover
       self.bisector.surface_result('BUILD_FAILURE')
       raise
+    self.build_id = result.stdout['results'][0]['build']['id']
 
   def _get_bisect_config_for_tester(self):
     """Copies the key-value pairs required by a tester bot to a new dict."""
     result = {}
     required_test_properties = {
         'truncate_percent',
         'metric',
         'command',
         'test_type'
     }
@@ skipping 153 matching lines @@
     else:
       next_revision_to_test.retest()
 
   def __repr__(self):
     if self.overall_return_code is not None:
       return ('RevisionState(rev=%s, values=%r, overall_return_code=%r, '
               'std_dev=%r)') % (self.revision_string(), self.values,
                                 self.overall_return_code, self.std_dev)
     return ('RevisionState(rev=%s, values=%r, mean_value=%r, std_dev=%r)' % (
         self.revision_string(), self.values, self.mean_value, self.std_dev))