Aborting bisect early when the bug specified in the bisect config is closed.

tools/auto_bisect/bisect_perf_regression.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Performance Test Bisect Tool
 
 This script bisects a series of changelists using binary search. It starts at
 a bad revision where a performance metric has regressed, and asks for a last
 known-good revision. It will then binary search across this revision range by
@@ skipping 36 matching lines @@
 import zipfile
 
 sys.path.append(os.path.join(
     os.path.dirname(__file__), os.path.pardir, 'telemetry'))
 
 from bisect_printer import BisectPrinter
 from bisect_results import BisectResults
 from bisect_state import BisectState
 import bisect_utils
 import builder
+import crbug_query
 import math_utils
 import request_build
 import source_control
 from telemetry.util import cloud_storage
 
 # The script is in chromium/src/tools/auto_bisect. Throughout this script,
 # we use paths to other things in the chromium/src repository.
 
 # Possible return values from BisectPerformanceMetrics.RunTest.
 BUILD_RESULT_SUCCEED = 0
@@ skipping 2070 matching lines @@
 
     Args:
       command_to_run: Specify the command to execute the performance test.
       good_revision: Number/tag of the known good revision.
       bad_revision: Number/tag of the known bad revision.
       metric: The performance metric to monitor.
 
     Returns:
       A BisectResults object.
     """
+
     # Choose depot to bisect first
     target_depot = 'chromium'
     if self.opts.target_platform == 'android-chrome':
       target_depot = 'android-chrome'
 
     cwd = os.getcwd()
     self.depot_registry.ChangeToDepotDir(target_depot)
 
     # If they passed SVN revisions, we can try match them to git SHA1 hashes.
     bad_revision = source_control.ResolveToRevision(
@@ skipping 320 matching lines @@
     self.debug_ignore_perf_test = None
     self.debug_ignore_regression_confidence = None
     self.debug_fake_first_test_mean = 0
     self.gs_bucket = None
     self.target_arch = 'ia32'
     self.target_build_type = 'Release'
     self.builder_host = None
     self.builder_port = None
     self.bisect_mode = bisect_utils.BISECT_MODE_MEAN
     self.improvement_direction = 0
+    self.bug_id = ''
 
   @staticmethod
   def _AddBisectOptionsGroup(parser):
     group = parser.add_argument_group('Bisect options')
     group.add_argument('-c', '--command', required=True,
                        help='A command to execute your performance test at '
                             'each point in the bisection.')
     group.add_argument('-b', '--bad_revision', required=True,
                        help='A bad revision to start bisection. Must be later '
                             'than good revision. May be either a git or svn '
@@ skipping 27 matching lines @@
                        help='The highest/lowest % are discarded to form a '
                             'truncated mean. Values will be clamped to range '
                             '[0, 25]. Default value is 25 (highest/lowest 25% '
                             'will be discarded).')
     group.add_argument('--bisect_mode', default=bisect_utils.BISECT_MODE_MEAN,
                        choices=[bisect_utils.BISECT_MODE_MEAN,
                                 bisect_utils.BISECT_MODE_STD_DEV,
                                 bisect_utils.BISECT_MODE_RETURN_CODE],
                        help='The bisect mode. Choices are to bisect on the '
                             'difference in mean, std_dev, or return_code.')
+    group.add_argument('--bug_id', type=str, default='',
+                       help='The id for the bug associated with this bisect. ' +
+                       'If this number is given, bisect will attempt to ' +
+                       ' verify that the bug is not closed before starting.')
 
   @staticmethod
   def _AddBuildOptionsGroup(parser):
     group = parser.add_argument_group('Build options')
     group.add_argument('-w', '--working_directory',
                        help='Path to the working directory where the script '
                        'will do an initial checkout of the chromium depot. The '
                        'files will be placed in a subdirectory "bisect" under '
                        'working_directory and that will be used to perform the '
                        'bisection. This parameter is optional, if it is not '
                        'supplied, the script will work from the current depot.')
-    group.add_argument('--build_preference', type='choice',
+    group.add_argument('--build_preference', type=str,
                        choices=['msvs', 'ninja', 'make'],
                        help='The preferred build system to use. On linux/mac '
                             'the options are make/ninja. On Windows, the '
                             'options are msvs/ninja.')
-    group.add_argument('--target_platform', type='choice', default='chromium',
+    group.add_argument('--target_platform', type=str, default='chromium',
                        choices=['chromium', 'android', 'android-chrome'],
                        help='The target platform. Choices are "chromium" '
                             '(current platform), or "android". If you specify '
                             'something other than "chromium", you must be '
                             'properly set up to build that platform.')
     group.add_argument('--no_custom_deps', dest='no_custom_deps',
                        action='store_true', default=False,
                        help='Run the script with custom_deps or not.')
     group.add_argument('--extra_src',
                        help='Path to a script which can be used to modify the '
                             'bisect script\'s behavior.')
     group.add_argument('--use_goma', action='store_true',
                        help='Add a bunch of extra threads for goma, and enable '
                             'goma')
     group.add_argument('--goma_dir',
                        help='Path to goma tools (or system default if not '
                             'specified).')
     group.add_argument('--goma_threads', type=int, default='64',
                        help='Number of threads for goma, only if using goma.')
     group.add_argument('--output_buildbot_annotations', action='store_true',
                        help='Add extra annotation output for buildbot.')
     group.add_argument('--gs_bucket', default='', dest='gs_bucket',
                        help='Name of Google Storage bucket to upload or '
                             'download build. e.g., chrome-perf')
-    group.add_argument('--target_arch', type='choice', default='ia32',
+    group.add_argument('--target_arch', type=str, default='ia32',
                        dest='target_arch', choices=['ia32', 'x64', 'arm'],
                        help='The target build architecture. Choices are "ia32" '
                             '(default), "x64" or "arm".')
-    group.add_argument('--target_build_type', type='choice', default='Release',
+    group.add_argument('--target_build_type', type=str, default='Release',
                        choices=['Release', 'Debug'],
                        help='The target build type. Choices are "Release" '
                             '(default), or "Debug".')
     group.add_argument('--builder_host', dest='builder_host',
                        help='Host address of server to produce build by '
                             'posting try job request.')
-    group.add_argument('--builder_port', dest='builder_port', type='int',
+    group.add_argument('--builder_port', dest='builder_port', type=int,
                        help='HTTP port of the server to produce build by '
                             'posting try job request.')
 
   @staticmethod
   def _AddDebugOptionsGroup(parser):
     group = parser.add_argument_group('Debug options')
     group.add_argument('--debug_ignore_build', action='store_true',
                        help='DEBUG: Don\'t perform builds.')
     group.add_argument('--debug_ignore_sync', action='store_true',
                        help='DEBUG: Don\'t perform syncs.')
     group.add_argument('--debug_ignore_perf_test', action='store_true',
                        help='DEBUG: Don\'t perform performance tests.')
     group.add_argument('--debug_ignore_regression_confidence',
                        action='store_true',
                        help='DEBUG: Don\'t score the confidence of the initial '
                             'good and bad revisions\' test results.')
-    group.add_argument('--debug_fake_first_test_mean', type='int', default='0',
+    group.add_argument('--debug_fake_first_test_mean', type=int, default='0',
                        help='DEBUG: When faking performance tests, return this '
                             'value as the mean of the first performance test, '
                             'and return a mean of 0.0 for further tests.')
     return group
 
   @classmethod
   def _CreateCommandLineParser(cls):
     """Creates a parser with bisect options.
 
     Returns:
       An instance of optparse.OptionParser.
     """
     usage = ('%prog [options] [-- chromium-options]\n'
              'Perform binary search on revision history to find a minimal '
              'range of revisions where a performance metric regressed.\n')
 
     parser = argparse.ArgumentParser(usage=usage)
     cls._AddBisectOptionsGroup(parser)
     cls._AddBuildOptionsGroup(parser)
     cls._AddDebugOptionsGroup(parser)
     return parser
 
   def ParseCommandLine(self):
     """Parses the command line for bisect options."""
     parser = self._CreateCommandLineParser()
-    opts, _ = parser.parse_args()
+    opts = parser.parse_args()
 
     try:
       if (not opts.metric and
           opts.bisect_mode != bisect_utils.BISECT_MODE_RETURN_CODE):
         raise RuntimeError('missing required parameter: --metric')
 
       if opts.gs_bucket:
         if not cloud_storage.List(opts.gs_bucket):
           raise RuntimeError('Invalid Google Storage: gs://%s' % opts.gs_bucket)
         if not opts.builder_host:
@@ skipping 60 matching lines @@
   logging.basicConfig(
       stream=logging.sys.stdout, level=logging.INFO, format=logging_format)
 
 
 def main():
   _ConfigureLogging()
   try:
     opts = BisectOptions()
     opts.ParseCommandLine()
 
+    if opts.bug_id:
+      if opts.output_buildbot_annotations:
+        bisect_utils.OutputAnnotationStepStart('Checking Issue Tracker')
+      issue_closed = crbug_query.checkIssueClosed(opts.bug_id)
+      if issue_closed:
+        print 'Aborting bisect because bug is closed'
+      else:
+        print 'Could not confirm bug is closed, proceeding.'
+      if opts.output_buildbot_annotations:
+        bisect_utils.OutputAnnotationStepClosed()
+      if issue_closed:
+        results = BisectResults(abort_reason='the bug is closed.')
+        bisect_test = BisectPerformanceMetrics(opts, os.getcwd())
+        bisect_test.printer.FormatAndPrintResults(results)
+        return 0
+
+
     if opts.extra_src:
       extra_src = bisect_utils.LoadExtraSrc(opts.extra_src)
       if not extra_src:
         raise RuntimeError('Invalid or missing --extra_src.')
       bisect_utils.AddAdditionalDepotInfo(extra_src.GetAdditionalDepotInfo())
 
     if opts.working_directory:
       custom_deps = bisect_utils.DEFAULT_GCLIENT_CUSTOM_DEPS
       if opts.no_custom_deps:
         custom_deps = None
@@ skipping 33 matching lines @@
       bisect_utils.OutputAnnotationStepStart('Results')
     print 'Error: ', e.message
     logging.warn('A RuntimeError was caught: %s', e.message)
     if opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
   return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())