path: root/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,
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'

# The root URL for official builds.
OFFICIAL_BASE_URL = 'http://master.chrome.corp.google.com/official_builds'

# Changelogs URL.
CHANGELOG_URL = 'http://build.chromium.org/f/chromium/' \
                'perf/dashboard/ui/changelog.html?url=/trunk/src&range=%d%%3A%d'

# Official Changelogs URL.
OFFICIAL_CHANGELOG_URL = 'http://omahaproxy.appspot.com/'\
                         'changelog?old_version=%s&new_version=%s'

# DEPS file URL.
DEPS_FILE= 'http://src.chromium.org/viewvc/chrome/trunk/src/DEPS?revision=%d'
# WebKit Changelogs URL.
WEBKIT_CHANGELOG_URL = 'http://trac.webkit.org/log/' \
                       'trunk/?rev=%d&stop_rev=%d&verbose=on&limit=10000'

DONE_MESSAGE = 'You are probably looking for a change made after ' \
               '%s (known good), but no later than %s (first known bad).'

###############################################################################

import math
import optparse
import os
import pipes
import re
import shutil
import subprocess
import sys
import tempfile
import threading
import urllib
from distutils.version import LooseVersion
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, is_official):
    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_official = is_official

    # 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._binary_name = 'chrome'
    elif self.platform == 'mac':
      self.archive_name = 'chrome-mac.zip'
      self._archive_extract_dir = 'chrome-mac'
    elif self.platform == 'win':
      self.archive_name = 'chrome-win32.zip'
      self._archive_extract_dir = 'chrome-win32'
      self._binary_name = 'chrome.exe'
    else:
      raise Exception('Invalid platform: %s' % self.platform)

    if is_official:
      if self.platform == 'linux':
        self._listing_platform_dir = 'lucid32bit/'
        self.archive_name = 'chrome-lucid32bit.zip'
        self._archive_extract_dir = 'chrome-lucid32bit'
      elif self.platform == 'linux64':
        self._listing_platform_dir = 'lucid64bit/'
        self.archive_name = 'chrome-lucid64bit.zip'
        self._archive_extract_dir = 'chrome-lucid64bit'
      elif self.platform == 'mac':
        self._listing_platform_dir = 'mac/'
        self._binary_name = 'Google Chrome.app/Contents/MacOS/Google Chrome'
      elif self.platform == 'win':
        self._listing_platform_dir = 'win/'
    else:
      if self.platform == 'linux' or self.platform == 'linux64':
        self.archive_name = 'chrome-linux.zip'
        self._archive_extract_dir = 'chrome-linux'
        if self.platform == 'linux':
          self._listing_platform_dir = 'Linux/'
        elif self.platform == 'linux64':
          self._listing_platform_dir = 'Linux_x64/'
      elif self.platform == 'mac':
        self._listing_platform_dir = 'Mac/'
        self._binary_name = 'Chromium.app/Contents/MacOS/Chromium'
      elif self.platform == 'win':
        self._listing_platform_dir = 'Win/'

  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."""
    if self.is_official:
      return "%s/%s/%s%s" % (
          OFFICIAL_BASE_URL, revision, self._listing_platform_dir,
          self.archive_name)
    else:
      return "%s/%s%s/%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)

  def ParseDirectoryIndex(self):
    """Parses the Google Storage directory listing into a list of revision
    numbers. The range starts with self.good_revision and goes until
    self.bad_revision."""

    def _FetchAndParse(url):
      """Fetches a URL and returns a 2-Tuple of ([revisions], next-marker). If
      next-marker is not None, then the listing is a partial listing and another
      fetch should be performed with next-marker being the marker= GET
      parameter."""
      handle = urllib.urlopen(url)
      document = ElementTree.parse(handle)

      # 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_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 = []
      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(self.GetListingURL())

    # If the result list was truncated, refetch with the next marker. Do this
    # until an entire directory listing is done.
    while next_marker:
      next_url = self.GetListingURL(next_marker)
      (new_revisions, next_marker) = _FetchAndParse(next_url)
      revisions.extend(new_revisions)
    return revisions

  def GetRevList(self):
    """Gets the list of revision 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
    revlist = map(int, self.ParseDirectoryIndex())
    revlist = [x for x in revlist if x >= int(minrev) and x <= int(maxrev)]
    revlist.sort()
    return revlist

  def GetOfficialBuildsList(self):
    """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 = []
    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()
        if build_number > maxrev:
          break
        if build_number >= minrev:
          final_list.append(str(build_number))
      except urllib.HTTPError, e:
        pass
    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):
      os.mkdir(dir)
    os.chdir(dir)
    # Extract files.
    for info in zf.infolist():
      name = info.filename
      if name.endswith('/'):  # dir
        if not os.path.isdir(name):
          os.makedirs(name)
      else:  # file
        dir = os.path.dirname(name)
        if not os.path.isdir(dir):
          os.makedirs(dir)
        out = open(name, 'wb')
        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, 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.isSet():
      raise RuntimeError("Aborting download of revision %s" % str(rev))
    if progress_event and progress_event.isSet():
      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.isSet():
      print
  except RuntimeError, e:
    pass


def RunRevision(context, revision, zipfile, profile, num_runs, args):
  """Given a zipped revision, unzip it and run the test."""
  print "Trying revision %s..." % str(revision)

  # Create a temp directory and unzip the revision into it.
  cwd = os.getcwd()
  tempdir = tempfile.mkdtemp(prefix='bisect_tmp')
  UnzipFilenameToDir(zipfile, tempdir)
  os.chdir(tempdir)

  # Run the build as many times as specified.
  testargs = [context.GetLaunchPath(), '--user-data-dir=%s' % profile] + args
  # The sandbox must be run as root on Official Chrome, so bypass it.
  if context.is_official and (context.platform == 'linux' or
      context.platform == 'linux64'):
    testargs.append('--no-sandbox')

  for i in range(0, num_runs):
    subproc = subprocess.Popen(testargs,
                               bufsize=-1,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE)
    (stdout, stderr) = subproc.communicate()

  os.chdir(cwd)
  try:
    shutil.rmtree(tempdir, True)
  except Exception, e:
    pass

  return (subproc.returncode, stdout, stderr)


def AskIsGoodBuild(rev, official_builds, 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('Revision %s is [(g)ood/(b)ad/(u)nknown/(q)uit]: ' %
                         str(rev))
    if response and response in ('g', 'b', 'u'):
      return response
    if response and response == 'q':
      raise SystemExit()


class DownloadJob(object):
  """DownloadJob represents a task to download a given Chromium revision."""
  def __init__(self, context, name, rev, zipfile):
    super(DownloadJob, self).__init__()
    # Store off the input parameters.
    self.context = context
    self.name = name
    self.rev = rev
    self.zipfile = zipfile
    self.quit_event = threading.Event()
    self.progress_event = threading.Event()

  def Start(self):
    """Starts the download."""
    fetchargs = (self.context,
                 self.rev,
                 self.zipfile,
                 self.quit_event,
                 self.progress_event)
    self.thread = threading.Thread(target=FetchRevision,
                                   name=self.name,
                                   args=fetchargs)
    self.thread.start()

  def Stop(self):
    """Stops the download which must have been started previously."""
    self.quit_event.set()
    self.thread.join()
    os.unlink(self.zipfile)

  def WaitFor(self):
    """Prints a message and waits for the download to complete. The download
    must have been started previously."""
    print "Downloading revision %s..." % str(self.rev)
    self.progress_event.set()  # Display progress of download.
    self.thread.join()


def Bisect(platform,
           official_builds,
           good_rev=0,
           bad_rev=0,
           num_runs=1,
           try_args=(),
           profile=None,
           evaluate=AskIsGoodBuild):
  """Given known good and known bad revisions, run a binary search on all
  archived revisions to determine the last known good revision.

  @param platform Which build to download/run ('mac', 'win', 'linux64', etc.).
  @param official_builds Specify build type (Chromium or Official build).
  @param good_rev Number/tag of the last known good revision.
  @param bad_rev Number/tag of the first known bad revision.
  @param num_runs Number of times to run each build for asking good/bad.
  @param try_args A tuple of arguments to pass to the test application.
  @param profile The name of the user profile to run with.
  @param evaluate A function which returns 'g' if the argument build is good,
                  'b' if it's bad or 'u' if unknown.

  Threading is used to fetch Chromium revisions in the background, speeding up
  the user's experience. For example, suppose the bounds of the search are
  good_rev=0, bad_rev=100. The first revision to be checked is 50. Depending on
  whether revision 50 is good or bad, the next revision to check will be either
  25 or 75. So, while revision 50 is being checked, the script will download
  revisions 25 and 75 in the background. Once the good/bad verdict on rev 50 is
  known:

    - If rev 50 is good, the download of rev 25 is cancelled, and the next test
      is run on rev 75.

    - If rev 50 is bad, the download of rev 75 is cancelled, and the next test
      is run on rev 25.
  """

  if not profile:
    profile = 'profile'

  context = PathContext(platform, good_rev, bad_rev, official_builds)
  cwd = os.getcwd()



  print "Downloading list of known revisions..."
  _GetDownloadPath = lambda rev: os.path.join(cwd,
      '%s-%s' % (str(rev), context.archive_name))
  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()

  # 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_fetch = None
    if down_pivot != pivot and down_pivot != good:
      down_rev = revlist[down_pivot]
      down_fetch = DownloadJob(context, 'down_fetch', down_rev,
                               _GetDownloadPath(down_rev))
      down_fetch.Start()

    up_pivot = int((bad - pivot) / 2) + pivot
    up_fetch = None
    if up_pivot != pivot and up_pivot != bad:
      up_rev = revlist[up_pivot]
      up_fetch = DownloadJob(context, 'up_fetch', up_rev,
                             _GetDownloadPath(up_rev))
      up_fetch.Start()

    # Run test on the pivot revision.
    (status, stdout, stderr) = RunRevision(context,
                                           rev,
                                           zipfile,
                                           profile,
                                           num_runs,
                                           try_args)
    os.unlink(zipfile)
    zipfile = None

    # Call the evaluate 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:
      answer = evaluate(rev, official_builds, status, stdout, stderr)
      if answer == 'g':
        good = pivot
        if down_fetch:
          down_fetch.Stop()  # Kill the download of the older revision.
        if up_fetch:
          up_fetch.WaitFor()
          pivot = up_pivot
          zipfile = up_fetch.zipfile
      elif answer == 'b':
        bad = pivot
        if up_fetch:
          up_fetch.Stop()  # Kill the download of the newer revision.
        if down_fetch:
          down_fetch.WaitFor()
          pivot = down_pivot
          zipfile = down_fetch.zipfile
      elif answer == 'u':
        # Nuke the revision from the revlist and choose a new pivot.
        revlist.pop(pivot)
        bad -= 1  # Assumes bad >= pivot.

        fetch = None
        if bad - good > 1:
          # Alternate between using down_pivot or up_pivot for the new pivot
          # point, without affecting the range. Do this instead of setting the
          # pivot to the midpoint of the new range because adjacent revisions
          # are likely affected by the same issue that caused the (u)nknown
          # response.
          if up_fetch and down_fetch:
            fetch = [up_fetch, down_fetch][len(revlist) % 2]
          elif up_fetch:
            fetch = up_fetch
          else:
            fetch = down_fetch
          fetch.WaitFor()
          if fetch == up_fetch:
            pivot = up_pivot - 1  # Subtracts 1 because revlist was resized.
          else:
            pivot = down_pivot
          zipfile = fetch.zipfile

        if down_fetch and fetch != down_fetch:
          down_fetch.Stop()
        if up_fetch and fetch != up_fetch:
          up_fetch.Stop()
      else:
        assert False, "Unexpected return value from evaluate(): " + answer
    except SystemExit:
      print "Cleaning up..."
      for f in [_GetDownloadPath(revlist[down_pivot]),
                _GetDownloadPath(revlist[up_pivot])]:
        try:
          os.unlink(f)
        except OSError:
          pass
      sys.exit(0)

    rev = revlist[pivot]

  return (revlist[good], revlist[bad])


def GetWebKitRevisionForChromiumRevision(rev):
  """Returns the webkit revision that was in chromium's DEPS file at
  chromium revision |rev|."""
  # . doesn't match newlines without re.DOTALL, so this is safe.
  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. Default is HEAD.')
  parser.add_option('-g', '--good', type = 'str',
                    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

  # Create the context. Initialize 0 for the revisions as they are set below.
  context = PathContext(opts.archive, 0, 0, opts.official_builds)
  # Pick a starting point, try to get HEAD for this.
  if opts.bad:
    bad_rev = opts.bad
  else:
    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.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)

  # Get corresponding webkit revisions.
  try:
    last_known_good_webkit_rev = GetWebKitRevisionForChromiumRevision(
        last_known_good_rev)
    first_known_bad_webkit_rev = GetWebKitRevisionForChromiumRevision(
        first_known_bad_rev)
  except Exception, e:
    # Silently ignore the failure.
    last_known_good_webkit_rev, first_known_bad_webkit_rev = 0, 0

  # We're done. Let the user know the results in an official manner.
  print DONE_MESSAGE % (str(last_known_good_rev), str(first_known_bad_rev))
  if last_known_good_webkit_rev != first_known_bad_webkit_rev:
    print 'WEBKIT CHANGELOG URL:'
    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())