1 #!/usr/bin/env python 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. 3 # Use of this source code is governed by a BSD-style license that can be 4 # found in the LICENSE file. 5 6 """Snapshot Build Bisect Tool 7 8 This script bisects a snapshot archive using binary search. It starts at 9 a bad revision (it will try to guess HEAD) and asks for a last known-good 10 revision. It will then binary search across this revision range by downloading, 11 unzipping, and opening Chromium for you. After testing the specific revision, 12 it will ask you whether it is good or bad before continuing the search. 13 """ 14 15 # The root URL for storage. 16 CHROMIUM_BASE_URL = 'http://commondatastorage.googleapis.com/chromium-browser-snapshots' 17 WEBKIT_BASE_URL = 'http://commondatastorage.googleapis.com/chromium-webkit-snapshots' 18 19 # The root URL for official builds. 20 OFFICIAL_BASE_URL = 'http://master.chrome.corp.google.com/official_builds' 21 22 # Changelogs URL. 23 CHANGELOG_URL = 'http://build.chromium.org/f/chromium/' \ 24 'perf/dashboard/ui/changelog.html?' \ 25 'url=/trunk/src&range=%d%%3A%d' 26 27 # Official Changelogs URL. 28 OFFICIAL_CHANGELOG_URL = 'http://omahaproxy.appspot.com/'\ 29 'changelog?old_version=%s&new_version=%s' 30 31 # DEPS file URL. 32 DEPS_FILE = 'http://src.chromium.org/viewvc/chrome/trunk/src/DEPS?revision=%d' 33 # Blink Changelogs URL. 34 BLINK_CHANGELOG_URL = 'http://build.chromium.org/f/chromium/' \ 35 'perf/dashboard/ui/changelog_blink.html?' \ 36 'url=/trunk&range=%d%%3A%d' 37 38 DONE_MESSAGE_GOOD_MIN = 'You are probably looking for a change made after %s ' \ 39 '(known good), but no later than %s (first known bad).' 40 DONE_MESSAGE_GOOD_MAX = 'You are probably looking for a change made after %s ' \ 41 '(known bad), but no later than %s (first known good).' 42 43 ############################################################################### 44 45 import json 46 import optparse 47 import os 48 import re 49 import shlex 50 import shutil 51 import subprocess 52 import sys 53 import tempfile 54 import threading 55 import urllib 56 from distutils.version import LooseVersion 57 from xml.etree import ElementTree 58 import zipfile 59 60 61 class PathContext(object): 62 """A PathContext is used to carry the information used to construct URLs and 63 paths when dealing with the storage server and archives.""" 64 def __init__(self, base_url, platform, good_revision, bad_revision, 65 is_official, is_aura, flash_path = None): 66 super(PathContext, self).__init__() 67 # Store off the input parameters. 68 self.base_url = base_url 69 self.platform = platform # What's passed in to the '-a/--archive' option. 70 self.good_revision = good_revision 71 self.bad_revision = bad_revision 72 self.is_official = is_official 73 self.is_aura = is_aura 74 self.flash_path = flash_path 75 76 # The name of the ZIP file in a revision directory on the server. 77 self.archive_name = None 78 79 # Set some internal members: 80 # _listing_platform_dir = Directory that holds revisions. Ends with a '/'. 81 # _archive_extract_dir = Uncompressed directory in the archive_name file. 82 # _binary_name = The name of the executable to run. 83 if self.platform in ('linux', 'linux64', 'linux-arm'): 84 self._binary_name = 'chrome' 85 elif self.platform == 'mac': 86 self.archive_name = 'chrome-mac.zip' 87 self._archive_extract_dir = 'chrome-mac' 88 elif self.platform == 'win': 89 self.archive_name = 'chrome-win32.zip' 90 self._archive_extract_dir = 'chrome-win32' 91 self._binary_name = 'chrome.exe' 92 else: 93 raise Exception('Invalid platform: %s' % self.platform) 94 95 if is_official: 96 if self.platform == 'linux': 97 self._listing_platform_dir = 'precise32bit/' 98 self.archive_name = 'chrome-precise32bit.zip' 99 self._archive_extract_dir = 'chrome-precise32bit' 100 elif self.platform == 'linux64': 101 self._listing_platform_dir = 'precise64bit/' 102 self.archive_name = 'chrome-precise64bit.zip' 103 self._archive_extract_dir = 'chrome-precise64bit' 104 elif self.platform == 'mac': 105 self._listing_platform_dir = 'mac/' 106 self._binary_name = 'Google Chrome.app/Contents/MacOS/Google Chrome' 107 elif self.platform == 'win': 108 if self.is_aura: 109 self._listing_platform_dir = 'win-aura/' 110 else: 111 self._listing_platform_dir = 'win/' 112 else: 113 if self.platform in ('linux', 'linux64', 'linux-arm'): 114 self.archive_name = 'chrome-linux.zip' 115 self._archive_extract_dir = 'chrome-linux' 116 if self.platform == 'linux': 117 self._listing_platform_dir = 'Linux/' 118 elif self.platform == 'linux64': 119 self._listing_platform_dir = 'Linux_x64/' 120 elif self.platform == 'linux-arm': 121 self._listing_platform_dir = 'Linux_ARM_Cross-Compile/' 122 elif self.platform == 'mac': 123 self._listing_platform_dir = 'Mac/' 124 self._binary_name = 'Chromium.app/Contents/MacOS/Chromium' 125 elif self.platform == 'win': 126 self._listing_platform_dir = 'Win/' 127 128 def GetListingURL(self, marker=None): 129 """Returns the URL for a directory listing, with an optional marker.""" 130 marker_param = '' 131 if marker: 132 marker_param = '&marker=' + str(marker) 133 return self.base_url + '/?delimiter=/&prefix=' + \ 134 self._listing_platform_dir + marker_param 135 136 def GetDownloadURL(self, revision): 137 """Gets the download URL for a build archive of a specific revision.""" 138 if self.is_official: 139 return "%s/%s/%s%s" % ( 140 OFFICIAL_BASE_URL, revision, self._listing_platform_dir, 141 self.archive_name) 142 else: 143 return "%s/%s%s/%s" % (self.base_url, self._listing_platform_dir, 144 revision, self.archive_name) 145 146 def GetLastChangeURL(self): 147 """Returns a URL to the LAST_CHANGE file.""" 148 return self.base_url + '/' + self._listing_platform_dir + 'LAST_CHANGE' 149 150 def GetLaunchPath(self): 151 """Returns a relative path (presumably from the archive extraction location) 152 that is used to run the executable.""" 153 return os.path.join(self._archive_extract_dir, self._binary_name) 154 155 def IsAuraBuild(self, build): 156 """Check the given build is Aura.""" 157 return build.split('.')[3] == '1' 158 159 def IsASANBuild(self, build): 160 """Check the given build is ASAN build.""" 161 return build.split('.')[3] == '2' 162 163 def ParseDirectoryIndex(self): 164 """Parses the Google Storage directory listing into a list of revision 165 numbers.""" 166 167 def _FetchAndParse(url): 168 """Fetches a URL and returns a 2-Tuple of ([revisions], next-marker). If 169 next-marker is not None, then the listing is a partial listing and another 170 fetch should be performed with next-marker being the marker= GET 171 parameter.""" 172 handle = urllib.urlopen(url) 173 document = ElementTree.parse(handle) 174 175 # All nodes in the tree are namespaced. Get the root's tag name to extract 176 # the namespace. Etree does namespaces as |{namespace}tag|. 177 root_tag = document.getroot().tag 178 end_ns_pos = root_tag.find('}') 179 if end_ns_pos == -1: 180 raise Exception("Could not locate end namespace for directory index") 181 namespace = root_tag[:end_ns_pos + 1] 182 183 # Find the prefix (_listing_platform_dir) and whether or not the list is 184 # truncated. 185 prefix_len = len(document.find(namespace + 'Prefix').text) 186 next_marker = None 187 is_truncated = document.find(namespace + 'IsTruncated') 188 if is_truncated is not None and is_truncated.text.lower() == 'true': 189 next_marker = document.find(namespace + 'NextMarker').text 190 191 # Get a list of all the revisions. 192 all_prefixes = document.findall(namespace + 'CommonPrefixes/' + 193 namespace + 'Prefix') 194 # The <Prefix> nodes have content of the form of 195 # |_listing_platform_dir/revision/|. Strip off the platform dir and the 196 # trailing slash to just have a number. 197 revisions = [] 198 for prefix in all_prefixes: 199 revnum = prefix.text[prefix_len:-1] 200 try: 201 revnum = int(revnum) 202 revisions.append(revnum) 203 except ValueError: 204 pass 205 return (revisions, next_marker) 206 207 # Fetch the first list of revisions. 208 (revisions, next_marker) = _FetchAndParse(self.GetListingURL()) 209 210 # If the result list was truncated, refetch with the next marker. Do this 211 # until an entire directory listing is done. 212 while next_marker: 213 next_url = self.GetListingURL(next_marker) 214 (new_revisions, next_marker) = _FetchAndParse(next_url) 215 revisions.extend(new_revisions) 216 return revisions 217 218 def GetRevList(self): 219 """Gets the list of revision numbers between self.good_revision and 220 self.bad_revision.""" 221 # Download the revlist and filter for just the range between good and bad. 222 minrev = min(self.good_revision, self.bad_revision) 223 maxrev = max(self.good_revision, self.bad_revision) 224 revlist_all = map(int, self.ParseDirectoryIndex()) 225 226 revlist = [x for x in revlist_all if x >= int(minrev) and x <= int(maxrev)] 227 revlist.sort() 228 229 # Set good and bad revisions to be legit revisions. 230 if revlist: 231 if self.good_revision < self.bad_revision: 232 self.good_revision = revlist[0] 233 self.bad_revision = revlist[-1] 234 else: 235 self.bad_revision = revlist[0] 236 self.good_revision = revlist[-1] 237 238 # Fix chromium rev so that the deps blink revision matches REVISIONS file. 239 if self.base_url == WEBKIT_BASE_URL: 240 revlist_all.sort() 241 self.good_revision = FixChromiumRevForBlink(revlist, 242 revlist_all, 243 self, 244 self.good_revision) 245 self.bad_revision = FixChromiumRevForBlink(revlist, 246 revlist_all, 247 self, 248 self.bad_revision) 249 return revlist 250 251 def GetOfficialBuildsList(self): 252 """Gets the list of official build numbers between self.good_revision and 253 self.bad_revision.""" 254 # Download the revlist and filter for just the range between good and bad. 255 minrev = min(self.good_revision, self.bad_revision) 256 maxrev = max(self.good_revision, self.bad_revision) 257 handle = urllib.urlopen(OFFICIAL_BASE_URL) 258 dirindex = handle.read() 259 handle.close() 260 build_numbers = re.findall(r'<a href="([0-9][0-9].*)/">', dirindex) 261 final_list = [] 262 i = 0 263 parsed_build_numbers = [LooseVersion(x) for x in build_numbers] 264 for build_number in sorted(parsed_build_numbers): 265 path = OFFICIAL_BASE_URL + '/' + str(build_number) + '/' + \ 266 self._listing_platform_dir + self.archive_name 267 i = i + 1 268 try: 269 connection = urllib.urlopen(path) 270 connection.close() 271 if build_number > maxrev: 272 break 273 if build_number >= minrev: 274 # If we are bisecting Aura, we want to include only builds which 275 # ends with ".1". 276 if self.is_aura: 277 if self.IsAuraBuild(str(build_number)): 278 final_list.append(str(build_number)) 279 # If we are bisecting only official builds (without --aura), 280 # we can not include builds which ends with '.1' or '.2' since 281 # they have different folder hierarchy inside. 282 elif (not self.IsAuraBuild(str(build_number)) and 283 not self.IsASANBuild(str(build_number))): 284 final_list.append(str(build_number)) 285 except urllib.HTTPError, e: 286 pass 287 return final_list 288 289 def UnzipFilenameToDir(filename, directory): 290 """Unzip |filename| to |directory|.""" 291 cwd = os.getcwd() 292 if not os.path.isabs(filename): 293 filename = os.path.join(cwd, filename) 294 zf = zipfile.ZipFile(filename) 295 # Make base. 296 if not os.path.isdir(directory): 297 os.mkdir(directory) 298 os.chdir(directory) 299 # Extract files. 300 for info in zf.infolist(): 301 name = info.filename 302 if name.endswith('/'): # dir 303 if not os.path.isdir(name): 304 os.makedirs(name) 305 else: # file 306 directory = os.path.dirname(name) 307 if not os.path.isdir(directory): 308 os.makedirs(directory) 309 out = open(name, 'wb') 310 out.write(zf.read(name)) 311 out.close() 312 # Set permissions. Permission info in external_attr is shifted 16 bits. 313 os.chmod(name, info.external_attr >> 16L) 314 os.chdir(cwd) 315 316 317 def FetchRevision(context, rev, filename, quit_event=None, progress_event=None): 318 """Downloads and unzips revision |rev|. 319 @param context A PathContext instance. 320 @param rev The Chromium revision number/tag to download. 321 @param filename The destination for the downloaded file. 322 @param quit_event A threading.Event which will be set by the master thread to 323 indicate that the download should be aborted. 324 @param progress_event A threading.Event which will be set by the master thread 325 to indicate that the progress of the download should be 326 displayed. 327 """ 328 def ReportHook(blocknum, blocksize, totalsize): 329 if quit_event and quit_event.isSet(): 330 raise RuntimeError("Aborting download of revision %s" % str(rev)) 331 if progress_event and progress_event.isSet(): 332 size = blocknum * blocksize 333 if totalsize == -1: # Total size not known. 334 progress = "Received %d bytes" % size 335 else: 336 size = min(totalsize, size) 337 progress = "Received %d of %d bytes, %.2f%%" % ( 338 size, totalsize, 100.0 * size / totalsize) 339 # Send a \r to let all progress messages use just one line of output. 340 sys.stdout.write("\r" + progress) 341 sys.stdout.flush() 342 343 download_url = context.GetDownloadURL(rev) 344 try: 345 urllib.urlretrieve(download_url, filename, ReportHook) 346 if progress_event and progress_event.isSet(): 347 print 348 except RuntimeError, e: 349 pass 350 351 352 def RunRevision(context, revision, zipfile, profile, num_runs, command, args): 353 """Given a zipped revision, unzip it and run the test.""" 354 print "Trying revision %s..." % str(revision) 355 356 # Create a temp directory and unzip the revision into it. 357 cwd = os.getcwd() 358 tempdir = tempfile.mkdtemp(prefix='bisect_tmp') 359 UnzipFilenameToDir(zipfile, tempdir) 360 os.chdir(tempdir) 361 362 # Run the build as many times as specified. 363 testargs = ['--user-data-dir=%s' % profile] + args 364 # The sandbox must be run as root on Official Chrome, so bypass it. 365 if ((context.is_official or context.flash_path) and 366 context.platform.startswith('linux')): 367 testargs.append('--no-sandbox') 368 if context.flash_path: 369 testargs.append('--ppapi-flash-path=%s' % context.flash_path) 370 # We have to pass a large enough Flash version, which currently needs not 371 # be correct. Instead of requiring the user of the script to figure out and 372 # pass the correct version we just spoof it. 373 testargs.append('--ppapi-flash-version=99.9.999.999') 374 375 runcommand = [] 376 for token in shlex.split(command): 377 if token == "%a": 378 runcommand.extend(testargs) 379 else: 380 runcommand.append( \ 381 token.replace('%p', context.GetLaunchPath()) \ 382 .replace('%s', ' '.join(testargs))) 383 384 for i in range(0, num_runs): 385 subproc = subprocess.Popen(runcommand, 386 bufsize=-1, 387 stdout=subprocess.PIPE, 388 stderr=subprocess.PIPE) 389 (stdout, stderr) = subproc.communicate() 390 391 os.chdir(cwd) 392 try: 393 shutil.rmtree(tempdir, True) 394 except Exception, e: 395 pass 396 397 return (subproc.returncode, stdout, stderr) 398 399 400 def AskIsGoodBuild(rev, official_builds, status, stdout, stderr): 401 """Ask the user whether build |rev| is good or bad.""" 402 # Loop until we get a response that we can parse. 403 while True: 404 response = raw_input('Revision %s is ' \ 405 '[(g)ood/(b)ad/(r)etry/(u)nknown/(q)uit]: ' % 406 str(rev)) 407 if response and response in ('g', 'b', 'r', 'u'): 408 return response 409 if response and response == 'q': 410 raise SystemExit() 411 412 413 class DownloadJob(object): 414 """DownloadJob represents a task to download a given Chromium revision.""" 415 def __init__(self, context, name, rev, zipfile): 416 super(DownloadJob, self).__init__() 417 # Store off the input parameters. 418 self.context = context 419 self.name = name 420 self.rev = rev 421 self.zipfile = zipfile 422 self.quit_event = threading.Event() 423 self.progress_event = threading.Event() 424 425 def Start(self): 426 """Starts the download.""" 427 fetchargs = (self.context, 428 self.rev, 429 self.zipfile, 430 self.quit_event, 431 self.progress_event) 432 self.thread = threading.Thread(target=FetchRevision, 433 name=self.name, 434 args=fetchargs) 435 self.thread.start() 436 437 def Stop(self): 438 """Stops the download which must have been started previously.""" 439 self.quit_event.set() 440 self.thread.join() 441 os.unlink(self.zipfile) 442 443 def WaitFor(self): 444 """Prints a message and waits for the download to complete. The download 445 must have been started previously.""" 446 print "Downloading revision %s..." % str(self.rev) 447 self.progress_event.set() # Display progress of download. 448 self.thread.join() 449 450 451 def Bisect(base_url, 452 platform, 453 official_builds, 454 is_aura, 455 good_rev=0, 456 bad_rev=0, 457 num_runs=1, 458 command="%p %a", 459 try_args=(), 460 profile=None, 461 flash_path=None, 462 evaluate=AskIsGoodBuild): 463 """Given known good and known bad revisions, run a binary search on all 464 archived revisions to determine the last known good revision. 465 466 @param platform Which build to download/run ('mac', 'win', 'linux64', etc.). 467 @param official_builds Specify build type (Chromium or Official build). 468 @param good_rev Number/tag of the known good revision. 469 @param bad_rev Number/tag of the known bad revision. 470 @param num_runs Number of times to run each build for asking good/bad. 471 @param try_args A tuple of arguments to pass to the test application. 472 @param profile The name of the user profile to run with. 473 @param evaluate A function which returns 'g' if the argument build is good, 474 'b' if it's bad or 'u' if unknown. 475 476 Threading is used to fetch Chromium revisions in the background, speeding up 477 the user's experience. For example, suppose the bounds of the search are 478 good_rev=0, bad_rev=100. The first revision to be checked is 50. Depending on 479 whether revision 50 is good or bad, the next revision to check will be either 480 25 or 75. So, while revision 50 is being checked, the script will download 481 revisions 25 and 75 in the background. Once the good/bad verdict on rev 50 is 482 known: 483 484 - If rev 50 is good, the download of rev 25 is cancelled, and the next test 485 is run on rev 75. 486 487 - If rev 50 is bad, the download of rev 75 is cancelled, and the next test 488 is run on rev 25. 489 """ 490 491 if not profile: 492 profile = 'profile' 493 494 context = PathContext(base_url, platform, good_rev, bad_rev, 495 official_builds, is_aura, flash_path) 496 cwd = os.getcwd() 497 498 print "Downloading list of known revisions..." 499 _GetDownloadPath = lambda rev: os.path.join(cwd, 500 '%s-%s' % (str(rev), context.archive_name)) 501 if official_builds: 502 revlist = context.GetOfficialBuildsList() 503 else: 504 revlist = context.GetRevList() 505 506 # Get a list of revisions to bisect across. 507 if len(revlist) < 2: # Don't have enough builds to bisect. 508 msg = 'We don\'t have enough builds to bisect. revlist: %s' % revlist 509 raise RuntimeError(msg) 510 511 # Figure out our bookends and first pivot point; fetch the pivot revision. 512 minrev = 0 513 maxrev = len(revlist) - 1 514 pivot = maxrev / 2 515 rev = revlist[pivot] 516 zipfile = _GetDownloadPath(rev) 517 fetch = DownloadJob(context, 'initial_fetch', rev, zipfile) 518 fetch.Start() 519 fetch.WaitFor() 520 521 # Binary search time! 522 while fetch and fetch.zipfile and maxrev - minrev > 1: 523 if bad_rev < good_rev: 524 min_str, max_str = "bad", "good" 525 else: 526 min_str, max_str = "good", "bad" 527 print 'Bisecting range [%s (%s), %s (%s)].' % (revlist[minrev], min_str, \ 528 revlist[maxrev], max_str) 529 530 # Pre-fetch next two possible pivots 531 # - down_pivot is the next revision to check if the current revision turns 532 # out to be bad. 533 # - up_pivot is the next revision to check if the current revision turns 534 # out to be good. 535 down_pivot = int((pivot - minrev) / 2) + minrev 536 down_fetch = None 537 if down_pivot != pivot and down_pivot != minrev: 538 down_rev = revlist[down_pivot] 539 down_fetch = DownloadJob(context, 'down_fetch', down_rev, 540 _GetDownloadPath(down_rev)) 541 down_fetch.Start() 542 543 up_pivot = int((maxrev - pivot) / 2) + pivot 544 up_fetch = None 545 if up_pivot != pivot and up_pivot != maxrev: 546 up_rev = revlist[up_pivot] 547 up_fetch = DownloadJob(context, 'up_fetch', up_rev, 548 _GetDownloadPath(up_rev)) 549 up_fetch.Start() 550 551 # Run test on the pivot revision. 552 status = None 553 stdout = None 554 stderr = None 555 try: 556 (status, stdout, stderr) = RunRevision(context, 557 rev, 558 fetch.zipfile, 559 profile, 560 num_runs, 561 command, 562 try_args) 563 except Exception, e: 564 print >> sys.stderr, e 565 566 # Call the evaluate function to see if the current revision is good or bad. 567 # On that basis, kill one of the background downloads and complete the 568 # other, as described in the comments above. 569 try: 570 answer = evaluate(rev, official_builds, status, stdout, stderr) 571 if answer == 'g' and good_rev < bad_rev or \ 572 answer == 'b' and bad_rev < good_rev: 573 fetch.Stop() 574 minrev = pivot 575 if down_fetch: 576 down_fetch.Stop() # Kill the download of the older revision. 577 fetch = None 578 if up_fetch: 579 up_fetch.WaitFor() 580 pivot = up_pivot 581 fetch = up_fetch 582 elif answer == 'b' and good_rev < bad_rev or \ 583 answer == 'g' and bad_rev < good_rev: 584 fetch.Stop() 585 maxrev = pivot 586 if up_fetch: 587 up_fetch.Stop() # Kill the download of the newer revision. 588 fetch = None 589 if down_fetch: 590 down_fetch.WaitFor() 591 pivot = down_pivot 592 fetch = down_fetch 593 elif answer == 'r': 594 pass # Retry requires no changes. 595 elif answer == 'u': 596 # Nuke the revision from the revlist and choose a new pivot. 597 fetch.Stop() 598 revlist.pop(pivot) 599 maxrev -= 1 # Assumes maxrev >= pivot. 600 601 if maxrev - minrev > 1: 602 # Alternate between using down_pivot or up_pivot for the new pivot 603 # point, without affecting the range. Do this instead of setting the 604 # pivot to the midpoint of the new range because adjacent revisions 605 # are likely affected by the same issue that caused the (u)nknown 606 # response. 607 if up_fetch and down_fetch: 608 fetch = [up_fetch, down_fetch][len(revlist) % 2] 609 elif up_fetch: 610 fetch = up_fetch 611 else: 612 fetch = down_fetch 613 fetch.WaitFor() 614 if fetch == up_fetch: 615 pivot = up_pivot - 1 # Subtracts 1 because revlist was resized. 616 else: 617 pivot = down_pivot 618 zipfile = fetch.zipfile 619 620 if down_fetch and fetch != down_fetch: 621 down_fetch.Stop() 622 if up_fetch and fetch != up_fetch: 623 up_fetch.Stop() 624 else: 625 assert False, "Unexpected return value from evaluate(): " + answer 626 except SystemExit: 627 print "Cleaning up..." 628 for f in [_GetDownloadPath(revlist[down_pivot]), 629 _GetDownloadPath(revlist[up_pivot])]: 630 try: 631 os.unlink(f) 632 except OSError: 633 pass 634 sys.exit(0) 635 636 rev = revlist[pivot] 637 638 return (revlist[minrev], revlist[maxrev]) 639 640 641 def GetBlinkDEPSRevisionForChromiumRevision(rev): 642 """Returns the blink revision that was in REVISIONS file at 643 chromium revision |rev|.""" 644 # . doesn't match newlines without re.DOTALL, so this is safe. 645 blink_re = re.compile(r'webkit_revision\D*(\d+)') 646 url = urllib.urlopen(DEPS_FILE % rev) 647 m = blink_re.search(url.read()) 648 url.close() 649 if m: 650 return int(m.group(1)) 651 else: 652 raise Exception('Could not get Blink revision for Chromium rev %d' 653 % rev) 654 655 656 def GetBlinkRevisionForChromiumRevision(self, rev): 657 """Returns the blink revision that was in REVISIONS file at 658 chromium revision |rev|.""" 659 file_url = "%s/%s%d/REVISIONS" % (self.base_url, 660 self._listing_platform_dir, rev) 661 url = urllib.urlopen(file_url) 662 data = json.loads(url.read()) 663 url.close() 664 if 'webkit_revision' in data: 665 return data['webkit_revision'] 666 else: 667 raise Exception('Could not get blink revision for cr rev %d' % rev) 668 669 def FixChromiumRevForBlink(revisions_final, revisions, self, rev): 670 """Returns the chromium revision that has the correct blink revision 671 for blink bisect, DEPS and REVISIONS file might not match since 672 blink snapshots point to tip of tree blink. 673 Note: The revisions_final variable might get modified to include 674 additional revisions.""" 675 676 blink_deps_rev = GetBlinkDEPSRevisionForChromiumRevision(rev) 677 678 while (GetBlinkRevisionForChromiumRevision(self, rev) > blink_deps_rev): 679 idx = revisions.index(rev) 680 if idx > 0: 681 rev = revisions[idx-1] 682 if rev not in revisions_final: 683 revisions_final.insert(0, rev) 684 685 revisions_final.sort() 686 return rev 687 688 def GetChromiumRevision(url): 689 """Returns the chromium revision read from given URL.""" 690 try: 691 # Location of the latest build revision number 692 return int(urllib.urlopen(url).read()) 693 except Exception, e: 694 print('Could not determine latest revision. This could be bad...') 695 return 999999999 696 697 698 def main(): 699 usage = ('%prog [options] [-- chromium-options]\n' 700 'Perform binary search on the snapshot builds to find a minimal\n' 701 'range of revisions where a behavior change happened. The\n' 702 'behaviors are described as "good" and "bad".\n' 703 'It is NOT assumed that the behavior of the later revision is\n' 704 'the bad one.\n' 705 '\n' 706 'Revision numbers should use\n' 707 ' Official versions (e.g. 1.0.1000.0) for official builds. (-o)\n' 708 ' SVN revisions (e.g. 123456) for chromium builds, from trunk.\n' 709 ' Use base_trunk_revision from http://omahaproxy.appspot.com/\n' 710 ' for earlier revs.\n' 711 ' Chrome\'s about: build number and omahaproxy branch_revision\n' 712 ' are incorrect, they are from branches.\n' 713 '\n' 714 'Tip: add "-- --no-first-run" to bypass the first run prompts.') 715 parser = optparse.OptionParser(usage=usage) 716 # Strangely, the default help output doesn't include the choice list. 717 choices = ['mac', 'win', 'linux', 'linux64', 'linux-arm'] 718 # linux-chromiumos lacks a continuous archive http://crbug.com/78158 719 parser.add_option('-a', '--archive', 720 choices = choices, 721 help = 'The buildbot archive to bisect [%s].' % 722 '|'.join(choices)) 723 parser.add_option('-o', action="store_true", dest='official_builds', 724 help = 'Bisect across official ' + 725 'Chrome builds (internal only) instead of ' + 726 'Chromium archives.') 727 parser.add_option('-b', '--bad', type = 'str', 728 help = 'A bad revision to start bisection. ' + 729 'May be earlier or later than the good revision. ' + 730 'Default is HEAD.') 731 parser.add_option('-f', '--flash_path', type = 'str', 732 help = 'Absolute path to a recent Adobe Pepper Flash ' + 733 'binary to be used in this bisection (e.g. ' + 734 'on Windows C:\...\pepflashplayer.dll and on Linux ' + 735 '/opt/google/chrome/PepperFlash/libpepflashplayer.so).') 736 parser.add_option('-g', '--good', type = 'str', 737 help = 'A good revision to start bisection. ' + 738 'May be earlier or later than the bad revision. ' + 739 'Default is 0.') 740 parser.add_option('-p', '--profile', '--user-data-dir', type = 'str', 741 help = 'Profile to use; this will not reset every run. ' + 742 'Defaults to a clean profile.', default = 'profile') 743 parser.add_option('-t', '--times', type = 'int', 744 help = 'Number of times to run each build before asking ' + 745 'if it\'s good or bad. Temporary profiles are reused.', 746 default = 1) 747 parser.add_option('-c', '--command', type = 'str', 748 help = 'Command to execute. %p and %a refer to Chrome ' + 749 'executable and specified extra arguments respectively. ' + 750 'Use %s to specify all extra arguments as one string. ' + 751 'Defaults to "%p %a". Note that any extra paths ' + 752 'specified should be absolute.', 753 default = '%p %a') 754 parser.add_option('-l', '--blink', action='store_true', 755 help = 'Use Blink bisect instead of Chromium. ') 756 parser.add_option('--aura', 757 dest='aura', 758 action='store_true', 759 default=False, 760 help='Allow the script to bisect aura builds') 761 762 (opts, args) = parser.parse_args() 763 764 if opts.archive is None: 765 print 'Error: missing required parameter: --archive' 766 print 767 parser.print_help() 768 return 1 769 770 if opts.aura: 771 if opts.archive != 'win' or not opts.official_builds: 772 print 'Error: Aura is supported only on Windows platform '\ 773 'and official builds.' 774 return 1 775 776 if opts.blink: 777 base_url = WEBKIT_BASE_URL 778 else: 779 base_url = CHROMIUM_BASE_URL 780 781 # Create the context. Initialize 0 for the revisions as they are set below. 782 context = PathContext(base_url, opts.archive, 0, 0, 783 opts.official_builds, opts.aura, None) 784 # Pick a starting point, try to get HEAD for this. 785 if opts.bad: 786 bad_rev = opts.bad 787 else: 788 bad_rev = '999.0.0.0' 789 if not opts.official_builds: 790 bad_rev = GetChromiumRevision(context.GetLastChangeURL()) 791 792 # Find out when we were good. 793 if opts.good: 794 good_rev = opts.good 795 else: 796 good_rev = '0.0.0.0' if opts.official_builds else 0 797 798 if opts.flash_path: 799 flash_path = opts.flash_path 800 msg = 'Could not find Flash binary at %s' % flash_path 801 assert os.path.exists(flash_path), msg 802 803 if opts.official_builds: 804 good_rev = LooseVersion(good_rev) 805 bad_rev = LooseVersion(bad_rev) 806 else: 807 good_rev = int(good_rev) 808 bad_rev = int(bad_rev) 809 810 if opts.times < 1: 811 print('Number of times to run (%d) must be greater than or equal to 1.' % 812 opts.times) 813 parser.print_help() 814 return 1 815 816 (min_chromium_rev, max_chromium_rev) = Bisect( 817 base_url, opts.archive, opts.official_builds, opts.aura, good_rev, 818 bad_rev, opts.times, opts.command, args, opts.profile, opts.flash_path) 819 820 # Get corresponding blink revisions. 821 try: 822 min_blink_rev = GetBlinkRevisionForChromiumRevision(context, 823 min_chromium_rev) 824 max_blink_rev = GetBlinkRevisionForChromiumRevision(context, 825 max_chromium_rev) 826 except Exception, e: 827 # Silently ignore the failure. 828 min_blink_rev, max_blink_rev = 0, 0 829 830 if opts.blink: 831 # We're done. Let the user know the results in an official manner. 832 if good_rev > bad_rev: 833 print DONE_MESSAGE_GOOD_MAX % (str(min_blink_rev), str(max_blink_rev)) 834 else: 835 print DONE_MESSAGE_GOOD_MIN % (str(min_blink_rev), str(max_blink_rev)) 836 837 print 'BLINK CHANGELOG URL:' 838 print ' ' + BLINK_CHANGELOG_URL % (max_blink_rev, min_blink_rev) 839 840 else: 841 # We're done. Let the user know the results in an official manner. 842 if good_rev > bad_rev: 843 print DONE_MESSAGE_GOOD_MAX % (str(min_chromium_rev), 844 str(max_chromium_rev)) 845 else: 846 print DONE_MESSAGE_GOOD_MIN % (str(min_chromium_rev), 847 str(max_chromium_rev)) 848 if min_blink_rev != max_blink_rev: 849 print ("NOTE: There is a Blink roll in the range, " 850 "you might also want to do a Blink bisect.") 851 852 print 'CHANGELOG URL:' 853 if opts.official_builds: 854 print OFFICIAL_CHANGELOG_URL % (min_chromium_rev, max_chromium_rev) 855 else: 856 print ' ' + CHANGELOG_URL % (min_chromium_rev, max_chromium_rev) 857 858 if __name__ == '__main__': 859 sys.exit(main()) 860
