Change configs/try.py to get the list of config files to use from args.

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 188 matching lines @@
     else:
       logging.info('File gs://%s/%s not found in cloud storage.',
                     bucket_name, source_path)
   except Exception as e:
     logging.warn('Something went wrong while fetching file from cloud: %s', e)
     if os.path.exists(target_file):
       os.remove(target_file)
   return None
 
 
-# This is copied from build/scripts/common/chromium_utils.py.
-def MaybeMakeDirectory(*path):
-  """Creates an entire path, if it doesn't already exist."""
-  file_path = os.path.join(*path)
-  try:
-    os.makedirs(file_path)
-  except OSError as e:
-    if e.errno != errno.EEXIST:
-      return False
-  return True
-
-
 # This was copied from build/scripts/common/chromium_utils.py.
 def ExtractZip(filename, output_dir, verbose=True):
   """ Extract the zip archive in the output directory."""
   MaybeMakeDirectory(output_dir)
 
   # On Linux and Mac, we use the unzip command as it will
   # handle links and file bits (executable), which is much
   # easier then trying to do that with ZipInfo options.
   #
   # The Mac Version of unzip unfortunately does not support Zip64, whereas
@@ skipping 1037 matching lines @@
           diff_text = bisect_utils.CheckRunGit(diff_command, cwd=self.src_cwd)
           return (chromium_sha, ChangeBackslashToSlashInPatch(diff_text))
         else:
           raise RuntimeError(
               'Failed to update DEPS file for chromium: [%s]' % chromium_sha)
       else:
         raise RuntimeError(
             'DEPS checkout Failed for chromium revision : [%s]' % chromium_sha)
     return (None, None)
 
-  def _ObtainBuild(self, depot, revision=None):
+  def ObtainBuild(self, depot, revision=None):
     """Obtains a build by either downloading or building directly.
 
     Args:
       depot: Dependency repository name.
       revision: A git commit hash. If None is given, the currently checked-out
           revision is built.
 
     Returns:
       True for success.
     """
@@ skipping 317 matching lines @@
     Args:
       revision: The revision to sync to.
       depot: The depot that's being used at the moment (src, webkit, etc.)
       command: The command to execute the performance test.
       metric: The performance metric being tested.
 
     Returns:
       On success, a tuple containing the results of the performance test.
       Otherwise, a tuple with the error message.
     """
+    logging.info('Running RunTest with rev "%s", command "%s"',
+                 revision, command)
     # Decide which sync program to use.
     sync_client = None
     if depot == 'chromium' or depot == 'android-chrome':
       sync_client = 'gclient'
 
     # Decide what depots will need to be synced to what revisions.
     revisions_to_sync = self._FindAllRevisionsToSync(revision, depot)
     if not revisions_to_sync:
       return ('Failed to resolve dependent depots.', BUILD_RESULT_FAIL)
 
     # Do the syncing for all depots.
     if not self.opts.debug_ignore_sync:
       if not self._SyncAllRevisions(revisions_to_sync, sync_client):
         return ('Failed to sync: [%s]' % str(revision), BUILD_RESULT_FAIL)
 
     # Try to do any post-sync steps. This may include "gclient runhooks".
     if not self._RunPostSync(depot):
       return ('Failed to run [gclient runhooks].', BUILD_RESULT_FAIL)
 
     # Skip this revision if it can be skipped.
     if skippable and self.ShouldSkipRevision(depot, revision):
       return ('Skipped revision: [%s]' % str(revision),
               BUILD_RESULT_SKIPPED)
 
     # Obtain a build for this revision. This may be done by requesting a build
     # from another builder, waiting for it and downloading it.
     start_build_time = time.time()
-    build_success = self._ObtainBuild(depot, revision)
+    build_success = self.ObtainBuild(depot, revision)
     if not build_success:
       return ('Failed to build revision: [%s]' % str(revision),
               BUILD_RESULT_FAIL)
     after_build_time = time.time()
 
     # Possibly alter the command.
     command = self.GetCompatibleCommand(command, revision, depot)
 
     # Run the command and get the results.
     results = self.RunPerformanceTestAndParseResults(command, metric)
@@ skipping 762 matching lines @@
     opts: The options parsed from the command line.
 
   Returns:
     True if the platform and build system are supported.
   """
   # Haven't tested the script out on any other platforms yet.
   supported = ['posix', 'nt']
   return os.name in supported
 
 
+def RemoveBuildFiles(build_type):
+  """Removes build files from previous runs."""
+  out_dir = os.path.join('out', build_type)
+  build_dir = os.path.join('build', build_type)
+  logging.info('Removing build files in "%s" and "%s".',
+               os.path.abspath(out_dir), os.path.abspath(build_dir))
+  try:
+    RemakeDirectoryTree(out_dir)
+    RemakeDirectoryTree(build_dir)
+  except Exception as e:
+    raise RuntimeError('Got error in RemoveBuildFiles: %s' % e)
+
+
 def RemakeDirectoryTree(path_to_dir):
   """Removes a directory tree and replaces it with an empty one.
 
   Returns True if successful, False otherwise.
   """
-  if not RemoveDirectoryTree(path_to_dir):
-    return False
-  return MaybeMakeDirectory(path_to_dir)
+  RemoveDirectoryTree(path_to_dir)
+  MaybeMakeDirectory(path_to_dir)
 
 
 def RemoveDirectoryTree(path_to_dir):
   """Removes a directory tree. Returns True if successful or False otherwise."""
   try:
     if os.path.exists(path_to_dir):
       shutil.rmtree(path_to_dir)
   except OSError, e:
     if e.errno != errno.ENOENT:
-      return False
-  return True
+      raise
 
 
-def RemoveBuildFiles(build_type):
-  """Removes build files from previous runs."""
-  out_dir = os.path.join('out', build_type)
-  build_dir = os.path.join('build', build_type)
-  return RemakeDirectoryTree(out_dir) and RemakeDirectoryTree(build_dir)
+# This is copied from build/scripts/common/chromium_utils.py.
+def MaybeMakeDirectory(*path):
+  """Creates an entire path, if it doesn't already exist."""
+  file_path = os.path.join(*path)
+  try:
+    os.makedirs(file_path)
+  except OSError as e:
+    if e.errno != errno.EEXIST:
+      raise
 
 
 class BisectOptions(object):
   """Options to be used when running bisection."""
   def __init__(self):
     super(BisectOptions, self).__init__()
 
     self.target_platform = 'chromium'
     self.build_preference = None
     self.good_revision = None
@@ skipping 73 matching lines @@
   @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 73 matching lines @@
         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
       bisect_utils.CreateBisectDirectoryAndSetupDepot(opts, custom_deps)
 
       os.chdir(os.path.join(os.getcwd(), 'src'))
-
-      if not RemoveBuildFiles(opts.target_build_type):
-        raise RuntimeError('Something went wrong removing the build files.')
+      RemoveBuildFiles(opts.target_build_type)
 
     if not _IsPlatformSupported():
       raise RuntimeError('Sorry, this platform isn\'t supported yet.')
 
     if not source_control.IsInGitRepository():
       raise RuntimeError(
           'Sorry, only the git workflow is supported at the moment.')
 
     # gClient sync seems to fail if you're not in master branch.
     if (not source_control.IsInProperBranch() and
         not opts.debug_ignore_sync and
         not opts.working_directory):
       raise RuntimeError('You must switch to master branch to run bisection.')
     bisect_test = BisectPerformanceMetrics(opts, os.getcwd())
     try:
       results = bisect_test.Run(opts.command, opts.bad_revision,
                                 opts.good_revision, opts.metric)
       if results.error:
         raise RuntimeError(results.error)
       bisect_test.printer.FormatAndPrintResults(results)
       return 0
     finally:
       bisect_test.PerformCleanup()
-  except RuntimeError, e:
+  except RuntimeError as e:
     if opts.output_buildbot_annotations:
       # The perf dashboard scrapes the "results" step in order to comment on
       # bugs. If you change this, please update the perf dashboard as well.
       bisect_utils.OutputAnnotationStepStart('Results')
-    print 'Error: ', e.message
-    logging.warn('A RuntimeError was caught: %s', e.message)
+    print 'Runtime Error: %s' % e
     if opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
   return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())