[tools] Add --times option to bisect-builds.py

tools/bisect-builds.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Snapshot Build Bisect Tool
 
 This script bisects a snapshot archive using binary search. It starts at
 a bad revision (it will try to guess HEAD) and asks for a last known-good
 revision. It will then binary search across this revision range by downloading,
@@ skipping 224 matching lines @@
 
   download_url = context.GetDownloadURL(rev)
   try:
     urllib.urlretrieve(download_url, filename, ReportHook)
     if progress_event and progress_event.isSet():
       print
   except RuntimeError, e:
     pass
 
 
-def RunRevision(context, revision, zipfile, profile, args):
+def RunRevision(context, revision, zipfile, profile, num_runs, args):
   """Given a zipped revision, unzip it and run the test."""
   print "Trying revision %d..." % revision
 
   # Create a temp directory and unzip the revision into it.
   cwd = os.getcwd()
   tempdir = tempfile.mkdtemp(prefix='bisect_tmp')
   UnzipFilenameToDir(zipfile, tempdir)
   os.chdir(tempdir)
 
-  # Run the build.
+  # Run the build as many times as specified.
   testargs = [context.GetLaunchPath(), '--user-data-dir=%s' % profile] + args
-  subproc = subprocess.Popen(testargs,
-                             bufsize=-1,
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-  (stdout, stderr) = subproc.communicate()
+  for i in range(0, num_runs):
+    subproc = subprocess.Popen(testargs,
+                               bufsize=-1,
+                               stdout=subprocess.PIPE,
+                               stderr=subprocess.PIPE)
+    (stdout, stderr) = subproc.communicate()
 
   os.chdir(cwd)
   try:
     shutil.rmtree(tempdir, True)
   except Exception, e:
     pass
 
   return (subproc.returncode, stdout, stderr)
 
 
 def AskIsGoodBuild(rev, status, stdout, stderr):
   """Ask the user whether build |rev| is good or bad."""
   # Loop until we get a response that we can parse.
   while True:
     response = raw_input('Revision %d is [(g)ood/(b)ad/(q)uit]: ' % int(rev))
     if response and response in ('g', 'b'):
       return response == 'g'
     if response and response == 'q':
       raise SystemExit()
 
 
 def Bisect(platform,
            good_rev=0,
            bad_rev=0,
+           num_runs=1,
            try_args=(),
            profile=None,
            predicate=AskIsGoodBuild):
   """Given known good and known bad revisions, run a binary search on all
   archived revisions to determine the last known good revision.
 
   @param platform Which build to download/run ('mac', 'win', 'linux64', etc.).
   @param good_rev Number/tag of the last known good revision.
   @param bad_rev Number/tag of the first known bad revision.
+  @param num_runs Number of times to run each build for asking good/bad.
   @param try_args A tuple of arguments to pass to the test application.
   @param profile The name of the user profile to run with.
   @param predicate A predicate function which returns True iff the argument
                    chromium revision is good.
 
   Threading is used to fetch Chromium revisions in the background, speeding up
   the user's experience. For example, suppose the bounds of the search are
   good_rev=0, bad_rev=100. The first revision to be checked is 50. Depending on
   whether revision 50 is good or bad, the next revision to check will be either
   25 or 75. So, while revision 50 is being checked, the script will download
@@ skipping 76 matching lines @@
       up_thread = threading.Thread(target=FetchRevision,
                                    name='up_fetch',
                                    args=fetchargs)
       up_thread.start()
 
     # Run test on the pivot revision.
     (status, stdout, stderr) = RunRevision(context,
                                            rev,
                                            zipfile,
                                            profile,
+                                           num_runs,
                                            try_args)
     os.unlink(zipfile)
     zipfile = None
 
     # Call the predicate function to see if the current revision is good or bad.
     # On that basis, kill one of the background downloads and complete the
     # other, as described in the comments above.
     try:
       if predicate(rev, status, stdout, stderr):
         good = pivot
@@ skipping 14 matching lines @@
           up_thread.join()
           os.unlink(up_zipfile)
         if down_thread:
           print "Downloading revision %d..." % down_rev
           down_progress_event.set()  # Display progress of download.
           down_thread.join()  # Wait for older revision to finish downloading.
           pivot = down_pivot
           zipfile = down_zipfile
     except SystemExit:
       print "Cleaning up..."
-      for f in [down_zipfile, up_zipfile]:
+      for f in [_GetDownloadPath(revlist[down_pivot]),
+                _GetDownloadPath(revlist[up_pivot])]:
         try:
           os.unlink(f)
         except OSError:
           pass
       sys.exit(0)
 
     rev = revlist[pivot]
 
   return (revlist[good], revlist[bad])
 
@@ skipping 25 matching lines @@
                     choices = choices,
                     help = 'The buildbot archive to bisect [%s].' %
                            '|'.join(choices))
   parser.add_option('-b', '--bad', type = 'int',
                     help = 'The bad revision to bisect to.')
   parser.add_option('-g', '--good', type = 'int',
                     help = 'The last known good revision to bisect from.')
   parser.add_option('-p', '--profile', '--user-data-dir', type = 'str',
                     help = 'Profile to use; this will not reset every run. ' +
                     'Defaults to a clean profile.', default = 'profile')
+  parser.add_option('-t', '--times', type = 'int',
+                    help = 'Number of times to run each build before asking ' +
+                    'if it\'s good or bad. Temporary profiles are reused.',
+                    default = 1)
   (opts, args) = parser.parse_args()
 
   if opts.archive is None:
     print 'Error: missing required parameter: --archive'
     print
     parser.print_help()
     return 1
 
   if opts.bad and opts.good and (opts.good > opts.bad):
     print ('The good revision (%d) must precede the bad revision (%d).\n' %
@@ skipping 25 matching lines @@
   # Find out when we were good.
   if opts.good:
     good_rev = opts.good
   else:
     good_rev = 0
     try:
       good_rev = int(raw_input('Last known good [0]: '))
     except Exception, e:
       pass
 
+  if opts.times < 1:
+    print('Number of times to run (%d) must be greater than or equal to 1.' %
+          opts.times)
+    parser.print_help()
+    return 1
+
   (last_known_good_rev, first_known_bad_rev) = Bisect(
-      opts.archive, good_rev, bad_rev, args, opts.profile)
+      opts.archive, good_rev, bad_rev, opts.times, args, opts.profile)
 
   # Get corresponding webkit revisions.
   try:
     last_known_good_webkit_rev = GetWebKitRevisionForChromiumRevision(
         last_known_good_rev)
     first_known_bad_webkit_rev = GetWebKitRevisionForChromiumRevision(
         first_known_bad_rev)
   except Exception, e:
     # Silently ignore the failure.
     last_known_good_webkit_rev, first_known_bad_webkit_rev = 0, 0
 
   # We're done. Let the user know the results in an official manner.
   print('You are probably looking for build %d.' % first_known_bad_rev)
   if last_known_good_webkit_rev != first_known_bad_webkit_rev:
     print 'WEBKIT CHANGELOG URL:'
     print WEBKIT_CHANGELOG_URL % (first_known_bad_webkit_rev,
                                   last_known_good_webkit_rev)
   print 'CHANGELOG URL:'
   print CHANGELOG_URL % (last_known_good_rev, first_known_bad_rev)
   print 'Built at revision:'
   print BUILD_VIEWVC_URL % first_known_bad_rev
 
 
 if __name__ == '__main__':
   sys.exit(main())