Update bisect-builds.py to automatically determine download server.

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,
@@ skipping 186 matching lines @@
 def ParseDirectoryIndexRecent(context):
   """Parses the recent builds directory listing into a list of revision
   numbers."""
   handle = urllib.urlopen(context.GetListingURLRecent())
   document = handle.read()
 
   # Looking for: <a href="92976/">92976/</a>
   return re.findall(r"<a href=\"(\d+)/\">\1/</a>", document)
 
 
-def GetRevList(context):
-  """Gets the list of revision numbers between |good_revision| and
+def FilterRevList(context, revlist):
+  """Filter revlist to the revisions 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)
-  revisions = []
-  if context.use_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 110 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('-r', '--recent',
-                    dest = "recent",
-                    default = False,
-                    action = "store_true",
-                    help = 'Use recent builds from about the last 2 months ' +
-                    'for higher granularity bisecting.')
   (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' %
            (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, opts.recent)
+  context = PathContext(opts.archive, 0, 0, use_recent=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 13 matching lines @@
     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
 
-  # Get a list of revisions to bisect across.
-  revlist = GetRevList(context)
+  # Get recent revision list and check whether it's sufficient.
+  all_revs_recent = map(int, ParseDirectoryIndexRecent(context))
+  all_revs_recent.sort()
+  # Skipping 0 since it might be deleted off the server soon:
+  all_revs_recent = all_revs_recent[1:]
+  oldest_recent_rev = all_revs_recent[0]
+  if good_rev >= oldest_recent_rev:
+    # The range is within recent builds, so switch on use_recent.
+    context.use_recent = True
+  elif bad_rev >= oldest_recent_rev:
+    # The range spans both old and recent builds.
+    # If oldest_recent_rev is good, we bisect the recent builds.
+    context.use_recent = True
+    TryRevision(context, oldest_recent_rev, opts.profile, args)
+    if AskIsGoodBuild(oldest_recent_rev):
+      # context.use_recent is True
+      context.good_revision = oldest_recent_rev
+    else:
+      context.use_recent = False
+      context.bad_revision = oldest_recent_rev
+
+  all_revs = []
+  if context.use_recent:
+    all_revs = all_revs_recent
+  else:
+    all_revs = map(int, ParseDirectoryIndex(context))
+
+  # Filter list of revisions to bisect across.
+  revlist = FilterRevList(context, all_revs)
   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)
 
   (last_known_good_rev, first_known_bad_rev) = Bisect(
       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())