[chromedriver] Fix git migration issue and remove svn support from run_buildbot_steps.py

chrome/test/chromedriver/run_buildbot_steps.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Runs all the buildbot steps for ChromeDriver except for update/compile."""
 
 import bisect
 import csv
 import datetime
@@ skipping 34 matching lines @@
 sys.path.append(SCRIPT_DIR)
 sys.path.append(SITE_CONFIG_DIR)
 
 import archive
 import chrome_paths
 from slave import gsutil_download
 from slave import slave_utils
 import util
 
 
-def _ArchivePrebuilts(revision):
+def _ArchivePrebuilts(commit_position):
   """Uploads the prebuilts to google storage."""
   util.MarkBuildStepStart('archive prebuilts')
   zip_path = util.Zip(os.path.join(chrome_paths.GetBuildDir(['chromedriver']),
                                    'chromedriver'))
   if slave_utils.GSUtilCopy(
       zip_path,
-      '%s/%s' % (GS_PREBUILTS_URL, 'r%s.zip' % revision)):
+      '%s/%s' % (GS_PREBUILTS_URL, 'r%s.zip' % commit_position)):
     util.MarkBuildStepError()
 
 
 def _ArchiveServerLogs():
   """Uploads chromedriver server logs to google storage."""
   util.MarkBuildStepStart('archive chromedriver server logs')
   for server_log in glob.glob(os.path.join(tempfile.gettempdir(),
                                            'chromedriver_*')):
     base_name = os.path.basename(server_log)
     util.AddLink(base_name, '%s/%s' % (SERVER_LOGS_LINK, base_name))
@@ skipping 16 matching lines @@
   util.Unzip(zip_path, chrome_paths.GetBuildDir(['host_forwarder']))
 
 
 def _GetTestResultsLog(platform):
   """Gets the test results log for the given platform.
 
   Args:
     platform: The platform that the test results log is for.
 
   Returns:
-    A dictionary where the keys are SVN revisions and the values are booleans
+    A dictionary where the keys are commit positions and the values are booleans
     indicating whether the tests passed.
   """
   temp_log = tempfile.mkstemp()[1]
   log_name = TEST_LOG_FORMAT % platform
   result = slave_utils.GSUtilDownloadFile(
       '%s/%s' % (GS_CHROMEDRIVER_DATA_BUCKET, log_name), temp_log)
   if result:
     return {}
   with open(temp_log, 'rb') as log_file:
     json_dict = json.load(log_file)
   # Workaround for json encoding dictionary keys as strings.
   return dict([(int(v[0]), v[1]) for v in json_dict.items()])
 
 
 def _PutTestResultsLog(platform, test_results_log):
   """Pushes the given test results log to google storage."""
   temp_dir = util.MakeTempDir()
   log_name = TEST_LOG_FORMAT % platform
   log_path = os.path.join(temp_dir, log_name)
   with open(log_path, 'wb') as log_file:
     json.dump(test_results_log, log_file)
   if slave_utils.GSUtilCopyFile(log_path, GS_CHROMEDRIVER_DATA_BUCKET):
     raise Exception('Failed to upload test results log to google storage')
 
 
-def _UpdateTestResultsLog(platform, revision, passed):
+def _UpdateTestResultsLog(platform, commit_position, passed):
   """Updates the test results log for the given platform.
 
   Args:
     platform: The platform name.
-    revision: The SVN revision number.
-    passed: Boolean indicating whether the tests passed at this revision.
+    commit_position: The commit position number.
+    passed: Boolean indicating whether the tests passed at this commit position.
   """
-  assert isinstance(revision, int), 'The revision must be an integer'
+
+  assert commit_position.isdigit(), 'The commit position must be a number'
+  commit_position = int(commit_position)
   log = _GetTestResultsLog(platform)
   if len(log) > 500:
     del log[min(log.keys())]
-  assert revision not in log, 'Results already exist for revision %s' % revision
-  log[revision] = bool(passed)
+  assert commit_position not in log, \
+      'Results already exist for commit position %s' % commit_position
+  log[commit_position] = bool(passed)
   _PutTestResultsLog(platform, log)
 
 
 def _GetVersion():
   """Get the current chromedriver version."""
   with open(os.path.join(_THIS_DIR, 'VERSION'), 'r') as f:
     return f.read().strip()
 
 
 def _GetSupportedChromeVersions():
   """Get the minimum and maximum supported Chrome versions.
 
   Returns:
     A tuple of the form (min_version, max_version).
   """
   # Minimum supported Chrome version is embedded as:
   # const int kMinimumSupportedChromeVersion[] = {27, 0, 1453, 0};
   with open(os.path.join(_THIS_DIR, 'chrome', 'version.cc'), 'r') as f:
     lines = f.readlines()
     chrome_min_version_line = [
         x for x in lines if 'kMinimumSupportedChromeVersion' in x]
   chrome_min_version = chrome_min_version_line[0].split('{')[1].split(',')[0]
   with open(os.path.join(chrome_paths.GetSrc(), 'chrome', 'VERSION'), 'r') as f:
     chrome_max_version = f.readlines()[0].split('=')[1].strip()
   return (chrome_min_version, chrome_max_version)
 
 
-def _RevisionState(test_results_log, revision):
-  """Check the state of tests at a given SVN revision.
+def _CommitPositionState(test_results_log, commit_position):
+  """Check the state of tests at a given commit position.
 
-  Considers tests as having passed at a revision if they passed at revisons both
-  before and after.
+  Considers tests as having passed at a commit position if they passed at
+  revisons both before and after.
 
   Args:
     test_results_log: A test results log dictionary from _GetTestResultsLog().
-    revision: The revision to check at.
+    commit_position: The commit position to check at.
 
   Returns:
     'passed', 'failed', or 'unknown'
   """
-  assert isinstance(revision, int), 'The revision must be an integer'
+  assert isinstance(commit_position, int), 'The commit position must be an int'
   keys = sorted(test_results_log.keys())
-  # Return passed if the exact revision passed on Android.
-  if revision in test_results_log:
-    return 'passed' if test_results_log[revision] else 'failed'
-  # Tests were not run on this exact revision on Android.
-  index = bisect.bisect_right(keys, revision)
-  # Tests have not yet run on Android at or above this revision.
+  # Return passed if the exact commit position passed on Android.
+  if commit_position in test_results_log:
+    return 'passed' if test_results_log[commit_position] else 'failed'
+  # Tests were not run on this exact commit position on Android.
+  index = bisect.bisect_right(keys, commit_position)
+  # Tests have not yet run on Android at or above this commit position.
   if index == len(test_results_log):
     return 'unknown'
-  # No log exists for any prior revision, assume it failed.
+  # No log exists for any prior commit position, assume it failed.
   if index == 0:
     return 'failed'
-  # Return passed if the revisions on both sides passed.
+  # Return passed if the commit position on both sides passed.
   if test_results_log[keys[index]] and test_results_log[keys[index - 1]]:
     return 'passed'
   return 'failed'
 
 
-def _ArchiveGoodBuild(platform, revision):
+def _ArchiveGoodBuild(platform, commit_position):
   """Archive chromedriver binary if the build is green."""
   assert platform != 'android'
   util.MarkBuildStepStart('archive build')
 
   server_name = 'chromedriver'
   if util.IsWindows():
     server_name += '.exe'
   zip_path = util.Zip(os.path.join(chrome_paths.GetBuildDir([server_name]),
                                    server_name))
 
   build_name = 'chromedriver_%s_%s.%s.zip' % (
-      platform, _GetVersion(), revision)
+      platform, _GetVersion(), commit_position)
   build_url = '%s/%s' % (GS_CONTINUOUS_URL, build_name)
   if slave_utils.GSUtilCopy(zip_path, build_url):
     util.MarkBuildStepError()
 
   (latest_fd, latest_file) = tempfile.mkstemp()
   os.write(latest_fd, build_name)
   os.close(latest_fd)
   latest_url = '%s/latest_%s' % (GS_CONTINUOUS_URL, platform)
   if slave_utils.GSUtilCopy(latest_file, latest_url, mimetype='text/plain'):
     util.MarkBuildStepError()
@@ skipping 34 matching lines @@
     result = candidate_pattern.match(line)
     if not result:
       print 'Ignored line "%s"' % line
       continue
     candidates.append(int(result.group(1)))
 
   # Release the latest candidate build that passed Android, if any.
   # In this way, if a hot fix is needed, we can delete the release from
   # the chromedriver bucket instead of bumping up the release version number.
   candidates.sort(reverse=True)
-  for revision in candidates:
-    android_result = _RevisionState(android_test_results, revision)
+  for commit_position in candidates:
+    android_result = _CommitPositionState(android_test_results, commit_position)
     if android_result == 'failed':
-      print 'Android tests did not pass at revision', revision
+      print 'Android tests did not pass at commit position', commit_position
     elif android_result == 'passed':
-      print 'Android tests passed at revision', revision
-      candidate = 'chromedriver_%s_%s.%s.zip' % (platform, version, revision)
+      print 'Android tests passed at commit position', commit_position
+      candidate = 'chromedriver_%s_%s.%s.zip' % (
+          platform, version, commit_position)
       _Release('%s/%s' % (GS_CONTINUOUS_URL, candidate), version, platform)
       break
     else:
-      print 'Android tests have not run at a revision as recent as', revision
+      print 'Android tests have not run at a commit position as recent as', \
+          commit_position
 
 
 def _Release(build, version, platform):
   """Releases the given candidate build."""
   release_name = 'chromedriver_%s.zip' % platform
   util.MarkBuildStepStart('releasing %s' % release_name)
   temp_dir = util.MakeTempDir()
   slave_utils.GSUtilCopy(build, temp_dir)
   zip_path = os.path.join(temp_dir, os.path.basename(build))
 
@@ skipping 110 matching lines @@
     util.PrintAndFlush('URL Error %s' % error.message)
     return None
   data = json.loads(response.read()[4:])
   if 'message' in data:
     message = data['message'].split('\n')
     message = [line for line in message if line.strip()]
     search_pattern = re.compile(GS_SEARCH_PATTERN)
     result = search_pattern.search(message[len(message)-1])
     if result:
       return result.group(1)
-  util.PrintAndFlush('Failed to get svn revision number for %s' %
+  util.PrintAndFlush('Failed to get commit position number for %s' %
                      snapshot_hashcode)
   return None
 
 
 def _GetGitHashFromCommitPosition(commit_position):
   json_url = CR_REV_URL % commit_position
   try:
     response = urllib2.urlopen(json_url)
   except urllib2.HTTPError as error:
     util.PrintAndFlush('HTTP Error %d' % error.getcode())
     return None
   except urllib2.URLError as error:
     util.PrintAndFlush('URL Error %s' % error.message)
     return None
   data = json.loads(response.read())
   if 'git_sha' in data:
     return data['git_sha']
   util.PrintAndFlush('Failed to get git hash for %s' % commit_position)
   return None
 
 
-def _WaitForLatestSnapshot(revision):
+def _WaitForLatestSnapshot(commit_position):
   util.MarkBuildStepStart('wait_for_snapshot')
-  def _IsRevisionNumber(revision):
-    if isinstance(revision, int):
-      return True
-    else:
-      return revision.isdigit()
   while True:
-    snapshot_revision = archive.GetLatestSnapshotVersion()
-    if not _IsRevisionNumber(snapshot_revision):
-      snapshot_revision = _GetCommitPositionFromGitHash(snapshot_revision)
-    if revision is not None and snapshot_revision is not None:
-      if int(snapshot_revision) >= int(revision):
+    snapshot_position = archive.GetLatestSnapshotVersion()
+    if commit_position is not None and snapshot_position is not None:
+      if int(snapshot_position) >= int(commit_position):
         break
       util.PrintAndFlush('Waiting for snapshot >= %s, found %s' %
-                         (revision, snapshot_revision))
+                         (commit_position, snapshot_position))
     time.sleep(60)
-  util.PrintAndFlush('Got snapshot revision %s' % snapshot_revision)
+  util.PrintAndFlush('Got snapshot commit position %s' % snapshot_position)
 
 
 def _AddToolsToPath(platform_name):
   """Add some tools like Ant and Java to PATH for testing steps to use."""
   paths = []
   error_message = ''
   if platform_name == 'win32':
     paths = [
         # Path to Ant and Java, required for the java acceptance tests.
         'C:\\Program Files (x86)\\Java\\ant\\bin',
@@ skipping 18 matching lines @@
     os.environ['PATH'] += os.pathsep + os.pathsep.join(paths)
 
 
 def main():
   parser = optparse.OptionParser()
   parser.add_option(
       '', '--android-packages',
       help=('Comma separated list of application package names, '
             'if running tests on Android.'))
   parser.add_option(
-      '-r', '--revision', help='Chromium revision')
+      '-r', '--revision', help='Chromium git revision hash')
   parser.add_option(
       '', '--update-log', action='store_true',
       help='Update the test results log (only applicable to Android)')
   options, _ = parser.parse_args()
 
   bitness = '32'
   if util.IsLinux() and platform_module.architecture()[0] == '64bit':
     bitness = '64'
   platform = '%s%s' % (util.GetPlatformName(), bitness)
   if options.android_packages:
     platform = 'android'
 
   _CleanTmpDir()
 
   if not options.revision:
     commit_position = None
-  elif options.revision.isdigit():
-    commit_position = options.revision
   else:
     commit_position = _GetCommitPositionFromGitHash(options.revision)
 
   if platform == 'android':
     if not options.revision and options.update_log:
       parser.error('Must supply a --revision with --update-log')
     _DownloadPrebuilts()
   else:
     if not options.revision:
       parser.error('Must supply a --revision')
@@ skipping 28 matching lines @@
     util.MarkBuildStepStart('run_all_tests.py')
     util.MarkBuildStepError()
 
   # Add a "cleanup" step so that errors from runtest.py or bb_device_steps.py
   # (which invoke this script) are kept in thier own build step.
   util.MarkBuildStepStart('cleanup')
 
 
 if __name__ == '__main__':
   main()