Add programmatic interface

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-continuous'
+BASE_URL = 'http://commondatastorage.googleapis.com/chromium-browser-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'
 
 ###############################################################################
 
@@ skipping 50 matching lines @@
   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 GetDownloadURL(self, revision):
     """Gets the download URL for a build archive of a specific revision."""
-    return BASE_URL + '/' + self._listing_platform_dir + str(revision) + '/' + \
-        self.archive_name
+    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 43 matching lines @@
     # All nodes in the tree are namespaced. Get the root's tag name to extract
     # the namespace. Etree does namespaces as |{namespace}tag|.
     root_tag = document.getroot().tag
     end_ns_pos = root_tag.find('}')
     if end_ns_pos == -1:
       raise Exception("Could not locate end namespace for directory index")
     namespace = root_tag[:end_ns_pos + 1]
 
     # Find the prefix (_listing_platform_dir) and whether or not the list is
     # truncated.
-    prefix = document.find(namespace + 'Prefix').text
+    prefix_len = len(document.find(namespace + 'Prefix').text)
     next_marker = None
     is_truncated = document.find(namespace + 'IsTruncated')
     if is_truncated is not None and is_truncated.text.lower() == 'true':
       next_marker = document.find(namespace + 'NextMarker').text
 
     # Get a list of all the revisions.
     all_prefixes = document.findall(namespace + 'CommonPrefixes/' +
                                     namespace + 'Prefix')
     # The <Prefix> nodes have content of the form of
     # |_listing_platform_dir/revision/|. Strip off the platform dir and the
     # trailing slash to just have a number.
-    revisions = map(lambda x: x.text[len(prefix):-1], all_prefixes)
+    revisions = []
+    for prefix in all_prefixes:
+      revnum = prefix.text[prefix_len:-1]
+      try:
+        revnum = int(revnum)
+        revisions.append(revnum)
+      except ValueError:
+        pass
     return (revisions, next_marker)
 
   # Fetch the first list of revisions.
   (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)
@@ skipping 62 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,
+           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

[Robert Sesek, 2011/07/18 15:40:33]

nit: each of these should end with a full-stop

+  @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
+  """
+
+  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]
+      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.')
+                    'Defaults to a clean profile.', default = 'profile')
   (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 42 matching lines @@
     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]
 
   # These are indexes of |revlist|.
   good = 0
   bad = len(revlist) - 1
-  last_known_good_rev = revlist[good]
 
-  # 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).
-    profile = opts.profile
-    if not profile:
-      profile = 'profile'  # In a temp dir.
-    TryRevision(context, test_rev, profile, args)
-    if AskIsGoodBuild(test_rev):
-      last_known_good_rev = revlist[good]
-      good = test + 1
-    else:
-      bad = test
+  (last_known_good_rev, first_known_bad_rev) = Bisect(
+      good, bad, 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.' % revlist[bad])
+  print('You are probably looking for build %d.' % first_known_bad_rev)
   print('CHANGELOG URL:')
-  print(CHANGELOG_URL % (last_known_good_rev, revlist[bad]))
+  print(CHANGELOG_URL % (last_known_good_rev, first_known_bad_rev))
   print('Built at revision:')
-  print(BUILD_VIEWVC_URL % revlist[bad])
+  print(BUILD_VIEWVC_URL % first_known_bad_rev)
 
 if __name__ == '__main__':
   sys.exit(main())