Bisect official build with providing bad/good revisions.

tools/bisect-builds.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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 198 matching lines @@
     """Gets the list of official build numbers between self.good_revision and
     self.bad_revision."""
     # Download the revlist and filter for just the range between good and bad.
     minrev = self.good_revision
     maxrev = self.bad_revision
     handle = urllib.urlopen(OFFICIAL_BASE_URL)
     dirindex = handle.read()
     handle.close()
     build_numbers = re.findall(r'<a href="([0-9][0-9].*)/">', dirindex)
     final_list = []
-    start_index = 0
-    end_index = 0
     i = 0
-
     parsed_build_numbers = [LooseVersion(x) for x in build_numbers]
     for build_number in sorted(parsed_build_numbers):
       path = OFFICIAL_BASE_URL + '/' + str(build_number) + '/' + \
              self._listing_platform_dir + self.archive_name
       i = i + 1
       try:
         connection = urllib.urlopen(path)
         connection.close()
-        final_list.append(str(build_number))
-        if str(build_number) == minrev:
-          start_index = i
-        if str(build_number) == maxrev:
-          end_index = i
+        if build_number > maxrev:
+          break
+        if build_number >= minrev:
+          final_list.append(str(build_number))
       except urllib.HTTPError, e:
         pass
-    return final_list[start_index:end_index]
+    return final_list
 
 def UnzipFilenameToDir(filename, dir):
   """Unzip |filename| to directory |dir|."""
   cwd = os.getcwd()
   if not os.path.isabs(filename):
     filename = os.path.join(cwd, filename)
   zf = zipfile.ZipFile(filename)
   # Make base.
   try:
     if not os.path.isdir(dir):
@@ skipping 188 matching lines @@
   if official_builds:
     revlist = context.GetOfficialBuildsList()
   else:
     revlist = context.GetRevList()
 
   # Get a list of revisions to bisect across.
   if len(revlist) < 2:  # Don't have enough builds to bisect.
     msg = 'We don\'t have enough builds to bisect. revlist: %s' % revlist
     raise RuntimeError(msg)
 
+  print 'Bisecting range [%s, %s].' % (revlist[0], revlist[-1])
+
   # Figure out our bookends and first pivot point; fetch the pivot revision.
   good = 0
   bad = len(revlist) - 1
   pivot = bad / 2
   rev = revlist[pivot]
   zipfile = _GetDownloadPath(rev)
   initial_fetch = DownloadJob(context, 'initial_fetch', rev, zipfile)
   initial_fetch.Start()
   initial_fetch.WaitFor()
 
@@ skipping 104 matching lines @@
   webkit_re = re.compile(r'webkit_revision.:\D*(\d+)')
   url = urllib.urlopen(DEPS_FILE % rev)
   m = webkit_re.search(url.read())
   url.close()
   if m:
     return int(m.group(1))
   else:
     raise Exception('Could not get webkit revision for cr rev %d' % rev)
 
 
+def GetChromiumRevision(url):
+  """Returns the chromium revision read from given URL."""
+  try:
+    # Location of the latest build revision number
+    return int(urllib.urlopen(url).read())
+  except Exception, e:
+    print('Could not determine latest revision. This could be bad...')
+    return 999999999
+
+
 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('-o', action="store_true", dest='official_builds',
                     help = 'Bisect across official ' +
                     'Chrome builds (internal only) instead of ' +
                     'Chromium archives.')
   parser.add_option('-b', '--bad', type = 'str',
-                    help = 'The bad revision to bisect to.')
+                    help = 'The bad revision to bisect to. Default is HEAD.')
   parser.add_option('-g', '--good', type = 'str',
-                    help = 'The last known good revision to bisect from.')
+                    help = 'The last known good revision to bisect from. ' +
+                    'Default is 0.')
   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' %
-           (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.official_builds)
-
-  if opts.official_builds and opts.bad is None:
-    print >>sys.stderr, 'Bisecting official builds requires a bad build number.'
-    parser.print_help()
-    return 1
-
   # 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())
-      nh.close()
-      bad_rev = raw_input('Bad revision [HEAD:%d]: ' % latest)
-      if (bad_rev == ''):
-        bad_rev = latest
-      bad_rev = int(bad_rev)
-    except Exception, e:
-      print('Could not determine latest revision. This could be bad...')
-      bad_rev = int(raw_input('Bad revision: '))
+    bad_rev = '999.0.0.0'
+    if not opts.official_builds:
+      bad_rev = GetChromiumRevision(context.GetLastChangeURL())
 
   # 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
+    good_rev = '0.0.0.0' if opts.official_builds else 0
+
+  if opts.official_builds:
+    good_rev = LooseVersion(good_rev)
+    bad_rev = LooseVersion(bad_rev)
+  else:
+    good_rev = int(good_rev)
+    bad_rev = int(bad_rev)
+
+  if good_rev > bad_rev:
+    print ('The good revision (%s) must precede the bad revision (%s).\n' %
+           (good_rev, bad_rev))
+    parser.print_help()
+    return 1
 
   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, opts.official_builds, good_rev, bad_rev, opts.times, args,
       opts.profile)
@@ skipping 15 matching lines @@
     print '  ' + WEBKIT_CHANGELOG_URL % (first_known_bad_webkit_rev,
                                          last_known_good_webkit_rev)
   print 'CHANGELOG URL:'
   if opts.official_builds:
     print OFFICIAL_CHANGELOG_URL % (last_known_good_rev, first_known_bad_rev)
   else:
     print '  ' + CHANGELOG_URL % (last_known_good_rev, first_known_bad_rev)
 
 if __name__ == '__main__':
   sys.exit(main())