Restored download progress, and cleaned up terminal messages.

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 181 matching lines @@
         out.write(zf.read(name))
         out.close()
       # Set permissions. Permission info in external_attr is shifted 16 bits.
       os.chmod(name, info.external_attr >> 16L)
     os.chdir(cwd)
   except Exception, e:
     print >>sys.stderr, e
     sys.exit(1)
 
 
-def FetchRevision(context, rev, filename, quit_event=None):
+def FetchRevision(context, rev, filename, quit_event=None, progress_event=None):
   """Downloads and unzips revision |rev|.
   @param context A PathContext instance.
   @param rev The Chromium revision number/tag to download.
   @param filename The destination for the downloaded file.
   @param quit_event A threading.Event which will be set by the master thread to
                     indicate that the download should be aborted.
+  @param progress_event A threading.Event which will be set by the master thread
+                    to indicate that the progress of the download should be
+                    displayed.
   """
   def ReportHook(blocknum, blocksize, totalsize):
     if quit_event and quit_event.is_set():
      raise RuntimeError("Aborting download of revision %d" % rev)
+    if progress_event and progress_event.is_set():
+      size = blocknum * blocksize
+      if totalsize == -1:  # Total size not known.
+        progress = "Received %d bytes" % size
+      else:
+        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()
 
   download_url = context.GetDownloadURL(rev)
   try:
     urllib.urlretrieve(download_url, filename, ReportHook)
+    if progress_event and progress_event.is_set():
+      print()
   except RuntimeError, e:
     pass
 
 
 def RunRevision(context, revision, zipfile, profile, 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()
@@ skipping 14 matching lines @@
     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('\nRevision %d is [(g)ood/(b)ad/(q)uit]: ' % int(rev))
+    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,
            try_args=(),
            profile=None,
@@ skipping 26 matching lines @@
 
   if not profile:
     profile = 'profile'
 
   context = PathContext(platform, good_rev, bad_rev)
   cwd = os.getcwd()
 
   _GetDownloadPath = lambda rev: os.path.join(cwd,
       '%d-%s' % (rev, context.archive_name))
 
+  print "Downloading list of known revisions..."
+
   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)
 
   # 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)
+  progress_event = threading.Event()
+  progress_event.set()
   print "Downloading revision %d..." % rev
-  FetchRevision(context, rev, zipfile)
+  FetchRevision(context, rev, zipfile, None, progress_event)

[Nico, 2011/08/09 18:34:08]

I'd do
  FetchRevision(..., quit_event=None, progress_event=progress_event)
to make it clear what None means here

[szager1, 2011/08/09 18:39:06]

Done.

 
   # Binary search time!
   while zipfile and bad - good > 1:
     # Pre-fetch next two possible pivots
     #   - down_pivot is the next revision to check if the current revision turns
     #     out to be bad.
     #   - up_pivot is the next revision to check if the current revision turns
     #     out to be good.
     down_pivot = int((pivot - good) / 2) + good
     down_thread = None
     if down_pivot != pivot and down_pivot != good:
       down_rev = revlist[down_pivot]
       down_zipfile = _GetDownloadPath(down_rev)
-      down_event = threading.Event()
-      fetchargs = (context, down_rev, down_zipfile, down_event)
+      down_quit_event = threading.Event()
+      down_progress_event = threading.Event()
+      fetchargs = (context,
+                   down_rev,
+                   down_zipfile,
+                   down_quit_event,
+                   down_progress_event)
       down_thread = threading.Thread(target=FetchRevision,
                                      name='down_fetch',
                                      args=fetchargs)
       down_thread.start()
 
     up_pivot = int((bad - pivot) / 2) + pivot
     up_thread = None
     if up_pivot != pivot and up_pivot != bad:
       up_rev = revlist[up_pivot]
       up_zipfile = _GetDownloadPath(up_rev)
-      up_event = threading.Event()
-      fetchargs = (context, up_rev, up_zipfile, up_event)
+      up_quit_event = threading.Event()
+      up_progress_event = threading.Event()
+      fetchargs = (context,
+                   up_rev,
+                   up_zipfile,
+                   up_quit_event,
+                   up_progress_event)
       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,
                                            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
         if down_thread:
-          down_event.set()  # Kill the download of older revision.
+          down_quit_event.set()  # Kill the download of older revision.
           down_thread.join()
           os.unlink(down_zipfile)
         if up_thread:
           print "Downloading revision %d..." % up_rev
+          up_progress_event.set()  # Display progress of download.
           up_thread.join()  # Wait for newer revision to finish downloading.
           pivot = up_pivot
           zipfile = up_zipfile
       else:
         bad = pivot
         if up_thread:
-          up_event.set()  # Kill download of newer revision.
+          up_quit_event.set()  # Kill download of newer revision.
           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]:
         try:
           os.unlink(f)
         except OSError:
           pass
       sys.exit(0)
 
     rev = revlist[pivot]
 
   return (revlist[good], revlist[bad])
@@ skipping 69 matching lines @@
 
   # 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())