Update bisect-builds.py to support bisecting at better granularity

tools/bisect-builds.py

 #!/usr/bin/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,
 unzipping, and opening Chromium for you. After testing the specific revision,
 it will ask you whether it is good or bad before continuing the search.
 """
 
 # The root URL for storage.
 BASE_URL = 'http://commondatastorage.googleapis.com/chromium-browser-snapshots'
+BASE_URL_RECENT = 'http://build.chromium.org/f/chromium/snapshots'
 
 # URL to the ViewVC commit page.
 BUILD_VIEWVC_URL = 'http://src.chromium.org/viewvc/chrome?view=rev&revision=%d'
 
 # Changelogs URL.
 CHANGELOG_URL = 'http://build.chromium.org/f/chromium/' \
                 'perf/dashboard/ui/changelog.html?url=/trunk/src&range=%d:%d'
 
+# For BASE_URL_RECENT, the string prefix before each revision number.
+RECENT_REV_HTML_PREFIX = \
+    '<img src="/icons/folder.gif" alt="[DIR]"></td><td><a href="'
+
 ###############################################################################
 
 import math
 import optparse
 import os
 import pipes
 import re
 import shutil
 import sys
 import tempfile
 import urllib
 from xml.etree import ElementTree
 import zipfile
 
 class PathContext(object):
   """A PathContext is used to carry the information used to construct URLs and
   paths when dealing with the storage server and archives."""
-  def __init__(self, platform, good_revision, bad_revision):
+  def __init__(self, platform, good_revision, bad_revision, is_recent):

[Robert Sesek, 2011/07/20 19:05:11]

|is_recent| sounds like it's describing the context. I'd call this |use_recent|.

[jbates, 2011/07/20 21:08:42]

Done.

     super(PathContext, self).__init__()
     # Store off the input parameters.
     self.platform = platform  # What's passed in to the '-a/--archive' option.
     self.good_revision = good_revision
     self.bad_revision = bad_revision
+    self.is_recent = is_recent
 
     # The name of the ZIP file in a revision directory on the server.
     self.archive_name = None
 
     # Set some internal members:
     #   _listing_platform_dir = Directory that holds revisions. Ends with a '/'.
     #   _archive_extract_dir = Uncompressed directory in the archive_name file.
     #   _binary_name = The name of the executable to run.
     if self.platform == 'linux' or self.platform == 'linux64':
       self._listing_platform_dir = 'Linux/'
@@ skipping 17 matching lines @@
       raise Exception("Invalid platform")
 
   def GetListingURL(self, marker=None):
     """Returns the URL for a directory listing, with an optional marker."""
     marker_param = ''
     if marker:
       marker_param = '&marker=' + str(marker)
     return BASE_URL + '/?delimiter=/&prefix=' + self._listing_platform_dir + \
         marker_param
 
+  def GetListingURLRecent(self):
+    """Returns the URL for a directory listing of recent builds."""
+    return BASE_URL_RECENT + '/' + self._listing_platform_dir
+
   def GetDownloadURL(self, revision):
     """Gets the download URL for a build archive of a specific revision."""
-    return "%s/%s%d/%s" % (
-        BASE_URL, self._listing_platform_dir, revision, self.archive_name)
+    if self.is_recent:
+      return "%s/%s%d/%s" % (
+          BASE_URL_RECENT, self._listing_platform_dir, revision,
+          self.archive_name)
+    else:
+      return "%s/%s%d/%s" % (
+          BASE_URL, self._listing_platform_dir, revision, self.archive_name)
 
   def GetLastChangeURL(self):
     """Returns a URL to the LAST_CHANGE file."""
     return BASE_URL + '/' + self._listing_platform_dir + 'LAST_CHANGE'
 
   def GetLaunchPath(self):
     """Returns a relative path (presumably from the archive extraction location)
     that is used to run the executable."""
     return os.path.join(self._archive_extract_dir, self._binary_name)
 
@@ skipping 76 matching lines @@
   (revisions, next_marker) = _FetchAndParse(context.GetListingURL())
   # If the result list was truncated, refetch with the next marker. Do this
   # until an entire directory listing is done.
   while next_marker:
     (new_revisions, next_marker) = _FetchAndParse(
         context.GetListingURL(next_marker))
     revisions.extend(new_revisions)
 
   return revisions
 
+def ParseDirectoryIndexRecent(context):
+  """Parses the recent builds directory listing into a list of revision
+  numbers."""
+  revisions = []
+  handle = urllib.urlopen(context.GetListingURLRecent())
+  document = handle.read()
+
+  index = document.find(RECENT_REV_HTML_PREFIX)

[Robert Sesek, 2011/07/20 19:05:11]

Why not use a regex to do this? Use re.compile for the constant and then just
findall()?

[jbates, 2011/07/20 21:08:42]

Done.

+  while index > 0:
+    index += len(RECENT_REV_HTML_PREFIX)
+    end_slash_index = document.find('/', index)
+    rev = int(document[index: end_slash_index])
+    revisions.append(rev)
+    index = document.find(RECENT_REV_HTML_PREFIX, index)
+
+  return revisions
+
 
 def GetRevList(context):
   """Gets the list of revision numbers between |good_revision| and
   |bad_revision| of the |context|."""
   # Download the revlist and filter for just the range between good and bad.
   rev_range = range(context.good_revision, context.bad_revision)
-  revlist = map(int, ParseDirectoryIndex(context))
+  revisions = []
+  if context.is_recent:
+    revisions = ParseDirectoryIndexRecent(context)
+  else:
+    revisions = ParseDirectoryIndex(context)
+  revlist = map(int, revisions)
   revlist = filter(lambda r: r in rev_range, revlist)
   revlist.sort()
   return revlist
 
 
 def TryRevision(context, rev, profile, args):
   """Downloads revision |rev|, unzips it, and opens it for the user to test.
   |profile| is the profile to use."""
   # Do this in a temp dir so we don't collide with user files.
   cwd = os.getcwd()
@@ skipping 10 matching lines @@
       size = min(totalsize, size)
       progress = "Received %d of %d bytes, %.2f%%" % (
           size, totalsize, 100.0 * size / totalsize)
     # Send a \r to let all progress messages use just one line of output.
     sys.stdout.write("\r" + progress)
     sys.stdout.flush()
   try:
     print 'Fetching ' + download_url
     urllib.urlretrieve(download_url, context.archive_name, _ReportHook)
     print
+    # Throw an exception if the download was less than 1000 bytes.
+    if os.path.getsize(context.archive_name) < 1000: raise Exception()
   except Exception, e:
     print('Could not retrieve the download. Sorry.')
     sys.exit(-1)
 
   # Unzip the file.
   print 'Unzipping ...'
   UnzipFilenameToDir(context.archive_name, os.curdir)
 
   # Tell the system to open the app.
   args = ['--user-data-dir=%s' % profile] + args
@@ skipping 12 matching lines @@
 
 def AskIsGoodBuild(rev):
   """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('\nBuild %d is [(g)ood/(b)ad]: ' % int(rev))
     if response and response in ('g', 'b'):
       return response == 'g'
 
 
-def Bisect(good,
-           bad,
-           revlist,
+def Bisect(revlist,
            context,
            try_args=(),
            profile='profile',
            predicate=AskIsGoodBuild):
   """Tries to find the exact commit where a regression was introduced by
   running a binary search on all archived builds in a given revision range.
 
-  @param good The index in revlist of the last known good revision.
-  @param bad The index in revlist of the first known bad revision.
   @param revlist A list of chromium revision numbers to check.
   @param context A PathContext object.
   @param try_args A tuple of arguments to pass to the predicate function.
   @param profile The user profile with which to run chromium.
   @param predicate A predicate function which returns True iff the argument
                    chromium revision is good.
   """
 
+  good = 0
+  bad = len(revlist) - 1

[jbates, 2011/07/20 00:47:17]

Cleanup

   last_known_good_rev = revlist[good]
   first_known_bad_rev = revlist[bad]
 
   # Binary search time!
   while good < bad:
     candidates = revlist[good:bad]
     num_poss = len(candidates)
     if num_poss > 10:
       print('%d candidates. %d tries left.' %
           (num_poss, round(math.log(num_poss, 2))))
     else:
       print('Candidates: %s' % revlist[good:bad])
 
     # Cut the problem in half...
     test = int((bad - good) / 2) + good
     test_rev = revlist[test]
 
     # Let the user give this rev a spin (in her own profile, if she wants).
     TryRevision(context, test_rev, profile, try_args)
     if predicate(test_rev):
-      last_known_good_rev = revlist[good]
+      last_known_good_rev = test_rev

[jbates, 2011/07/20 00:47:17]

This fixes a bug that sometimes caused the reported URL to contain an extra set
of revisions.

[Robert Sesek, 2011/07/20 19:05:11]

Looks like this fixes http://code.google.com/p/chromium/issues/detail?id=82421 ?

If so, add a BUG= line to the CL description.

[jbates, 2011/07/20 21:08:42]

Done.

       good = test + 1
     else:
       bad = test
 
   return (last_known_good_rev, first_known_bad_rev)
 
 
 def main():
   usage = ('%prog [options] [-- chromium-options]\n'
            'Perform binary search on the snapshot builds.\n'
            '\n'
            'Tip: add "-- --no-first-run" to bypass the first run prompts.')
   parser = optparse.OptionParser(usage=usage)
   # Strangely, the default help output doesn't include the choice list.
   choices = ['mac', 'win', 'linux', 'linux64']
             # linux-chromiumos lacks a continuous archive http://crbug.com/78158
   parser.add_option('-a', '--archive',
                     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('-r', '--recent',
+                    dest = "recent",
+                    default = False,
+                    action = "store_true",
+                    help = 'Use recent builds from about the last 2 months ' +
+                    'for higher granularity bisecting.')
+  parser.add_option('-h', '--help',

[Robert Sesek, 2011/07/20 19:05:11]

I think this is done for you automatically by the option parser...

[jbates, 2011/07/20 21:08:42]

Done.

+                    dest = "help",
+                    default = False,
+                    action = "store_true",
+                    help = 'Show usage.')
   (opts, args) = parser.parse_args()
 
+  if opts.help:
+    parser.print_help()
+    return 0
+
   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' %
            (opts.good, opts.bad))
     parser.print_help()
     return 1
 
   # Create the context. Initialize 0 for the revisions as they are set below.
-  context = PathContext(opts.archive, 0, 0)
+  context = PathContext(opts.archive, 0, 0, False)
 
   # Pick a starting point, try to get HEAD for this.
   if opts.bad:
     bad_rev = opts.bad
   else:
     bad_rev = 0
     try:
       # Location of the latest build revision number
       nh = urllib.urlopen(context.GetLastChangeURL())
       latest = int(nh.read())
@@ skipping 12 matching lines @@
   else:
     good_rev = 0
     try:
       good_rev = int(raw_input('Last known good [0]: '))
     except Exception, e:
       pass
 
   # Set the input parameters now that they've been validated.
   context.good_revision = good_rev
   context.bad_revision = bad_rev
+  context.is_recent = opts.recent

[Robert Sesek, 2011/07/20 19:05:11]

You're not validating this, so why not pass it directly to the PathContext
constructor?

[jbates, 2011/07/20 21:08:42]

Done.

 
   # Get a list of revisions to bisect across.
   revlist = GetRevList(context)
   if len(revlist) < 2:  # Don't have enough builds to bisect
     print 'We don\'t have enough builds to bisect. revlist: %s' % revlist
     sys.exit(1)
 
-  # If we don't have a |good_rev|, set it to be the first revision possible.
-  if good_rev == 0:
-    good_rev = revlist[0]

[jbates, 2011/07/20 00:47:17]

good_rev is not used anymore, so this was unnecessary.

-
-  # These are indexes of |revlist|.
-  good = 0
-  bad = len(revlist) - 1

[jbates, 2011/07/20 00:47:17]

Moved to inside Bisect -- it already is passed the revlist.

-
   (last_known_good_rev, first_known_bad_rev) = Bisect(
-      good, bad, revlist, context, args, opts.profile)
+      revlist, context, args, opts.profile)
 
   # 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)
   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())