Adding ability to bisect recipe to bisect into dependency repos.

scripts/slave/recipe_modules/auto_bisect/perf_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.
 
 import json
+import tempfile
+import os
 import uuid
 
 from . import revision_state
 
+if 'CACHE_TEST_RESULTS' in os.environ:  # pragma: no cover
+  from . import test_results_cache
+
 
 class PerfRevisionState(revision_state.RevisionState):
 
   """Contains the state and results for one revision in a perf bisect job."""
   def __init__(self, *args, **kwargs):
     super(PerfRevisionState, self).__init__(*args, **kwargs)
     self.values = []
     self.mean_value = None
     self.std_err = None
+    self._test_config = None
 
   def test_info(self):
     """Returns a dictionary with information that describes this test.
 
     It is meant to be used by the bisector to describe the test being run for
     each revision evaluated.
     """
     return {
         'command': self._test_config['command'],
         'metric': self._test_config['metric'],
     }
 
   def _read_test_results(self):
     """Gets the test results from GS and checks if the rev is good or bad."""
     results = self._get_test_results()
     # Results will contain the keys 'results' and 'output' where output is the
     # stdout of the command, and 'results' is itself a dict with the keys:
     # 'mean', 'values', 'std_err'
     results = results['results']
     self.mean_value = results['mean']
     self.values = results['values']
     self.std_err = results['std_err']
     # We cannot test the goodness of the initial rev range.
     if self.bisector.good_rev != self and self.bisector.bad_rev != self:
       if self._check_revision_good():
         self.good = True
       else:
         self.bad = True
 
+  def _write_deps_patch_file(self, build_name):
+    api = self.bisector.api
+    file_name = os.path.join(tempfile.gettempdir(), build_name + '.diff')
+    api.m.file.write('Saving diff patch for ' + str(self.revision_string),
+                   file_name, self.deps_patch + self.deps_sha_patch)

[qyearsley, 2015/03/10 23:20:49]

Nit: Alignment.

[RobertoCN, 2015/03/13 20:55:59]

Done.

+    return file_name
+
   def _request_build(self):
     """Posts a request to buildbot to build this revision and archive it."""
     # TODO: Rewrite using the trigger module.
-    # TODO: Send a diff patch when appropriate
     api = self.bisector.api
     bot_name = self.bisector.get_builder_bot_for_this_platform()
     if self.bisector.dummy_builds:
       self.build_job_name = self.commit_hash + '-build'
     else:  # pragma: no cover
       self.build_job_name = uuid.uuid4().hex
+    if self.needs_patch:
+      self.patch_file = self._write_deps_patch_file(
+          self.build_job_name)
+    else:
+      self.patch_file = '/dev/null'
     try_cmd = [
         'try',
-        '--bot=%s' % bot_name,
-        '--revision=%s' % self.commit_hash,
-        '--name=%s' % self.build_job_name,
-        '--svn_repo=%s' % api.SVN_REPO_URL,
-        '--diff',
-        '/dev/null',
+        '--bot', bot_name,
+        '--revision', self.commit_hash,
+        '--name', self.build_job_name,
+        '--svn_repo', api.SVN_REPO_URL,
+        '--email', api.BOT_EMAIL,
+        '--diff', self.patch_file,
     ]
-    api.m.git(*try_cmd, name='Requesting build for %s via git try.'
-              % str(self.commit_hash))
+    try:
+      api.m.git(*try_cmd, name='Requesting build for %s via git try.'
+                % str(self.commit_hash))
+    finally:
+      if (self.patch_file != '/dev/null' and not 'TESTING_SLAVENAME' in
+          os.environ):
+        try:
+          api.m.step('cleaning up patch', ['rm', self.patch_file])
+        except api.m.step.StepFailure:  # pragma: no cover
+          print 'Could not clean up ' + self.patch_file
 
   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',
         'max_time_minutes',
         'command',
         'repeat_count',
         'test_type'
     }
     for k, v in self.bisector.bisect_config.iteritems():
       if k in required_test_properties:
         result[k] = v
     self._test_config = result
     return result
 
   def _do_test(self):
     """Posts a request to buildbot to download and perf-test this build."""
     if self.bisector.dummy_builds:
       self.test_job_name = self.commit_hash + '-test'
+    elif 'CACHE_TEST_RESULTS' in os.environ:  # pragma: no cover
+      self.test_job_name = test_results_cache.make_id(
+          self.revision_string, self._get_bisect_config_for_tester())
     else:  # pragma: no cover
       self.test_job_name = uuid.uuid4().hex
     api = self.bisector.api
     perf_test_properties = {
         'buildername': self.bisector.get_perf_tester_name(),
         'revision': self.revision_string,
         'parent_build_archive_url': self.build_url,
         'bisect_config': self._get_bisect_config_for_tester(),
         'job_name': self.test_job_name,
     }
+    if 'CACHE_TEST_RESULTS' in os.environ and test_results_cache.has_results(
+        self.test_job_name):  # pragma: no cover
+      return
     step_name = 'Triggering test job for ' + str(self.revision_string)
     api.m.trigger(perf_test_properties, name=step_name)
 
   def _get_build_status(self):
     """Queries buildbot through the json API to check if the job is done."""
     api = self.bisector.api
     try:
       stdout = api.m.raw_io.output()
       name = 'Get test status for build ' + self.commit_hash
       step_result = api.m.python(name, api.resource('check_job_status.py'),
@@ skipping 17 matching lines @@
     """
     api = self.bisector.api
     url_file_url = api.GS_RESULTS_URL + self.test_job_name
     try:
       stdout = api.m.raw_io.output()
       name = 'Get test status url for build ' + self.commit_hash
       step_result = api.m.gsutil.cat(url_file_url, stdout=stdout, name=name)
     except api.m.step.StepFailure:  # pragma: no cover
       return None
     else:
-      return step_result.stdout
+      url = step_result.stdout
+      if 'CACHE_TEST_RESULTS' in os.environ:  # pragma: no cover
+        test_results_cache.save_results(self.test_job_name, url)
+      return url
 
   def get_next_url(self):
     if not self.in_progress:
       return None
     if not self.built:
       return self.build_url
     if not self.build_status_url:
       # The file that will eventually contain the buildbot job url
       return self.bisector.api.GS_RESULTS_URL + self.test_job_name
     return self.build_status_url  # pragma: no cover
@@ skipping 23 matching lines @@
       True if this revision is closer to the initial good revision's value than
       to the initial bad revision's value. False otherwise.
     """
     # TODO: Reevaluate this approach
     bisector = self.bisector
     distance_to_good = abs(self.mean_value - bisector.good_rev.mean_value)
     distance_to_bad = abs(self.mean_value - bisector.bad_rev.mean_value)
     if distance_to_good < distance_to_bad:
       return True
     return False