Revert of 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):
-    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')
+    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]
 
   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:
-      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'}}]}))
+      api.m.buildbucket.put([build_details],
+                            api.m.service_account.get_json_path(
+                                api.SERVICE_ACCOUNT))
     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))