Trigger build request using git try instead of try_job_http on bisect bots

tools/auto_bisect/bisect_perf_regression.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.
 
 """Performance Test Bisect Tool
 
 This script bisects a series of changelists using binary search. It starts at
 a bad revision where a performance metric has regressed, and asks for a last
 known-good revision. It will then binary search across this revision range by
@@ skipping 158 matching lines @@
 
 # The confidence percentage at which confidence can be consider "high".
 HIGH_CONFIDENCE = 95
 
 # Patch template to add a new file, DEPS.sha under src folder.
 # This file contains SHA1 value of the DEPS changes made while bisecting
 # dependency repositories. This patch send along with DEPS patch to try server.
 # When a build requested is posted with a patch, bisect builders on try server,
 # once build is produced, it reads SHA value from this file and appends it
 # to build archive filename.
-DEPS_SHA_PATCH = """diff --git src/DEPS.sha src/DEPS.sha
+DEPS_SHA_PATCH = """diff --git DEPS.sha DEPS.sha
 new file mode 100644
 --- /dev/null
-+++ src/DEPS.sha
++++ DEPS.sha
 @@ -0,0 +1 @@
 +%(deps_sha)s
 """
 
 # The possible values of the --bisect_mode flag, which determines what to
 # use when classifying a revision as "good" or "bad".
 BISECT_MODE_MEAN = 'mean'
 BISECT_MODE_STD_DEV = 'std_dev'
 BISECT_MODE_RETURN_CODE = 'return_code'
 
@@ skipping 63 matching lines @@
 .     .---.         \      \==)
 .     |PERF\         \       \\
 .     |     ---------'-------'-----------.
 .     .     0 0 0 0 0 0 0 0 0 0 0 0 0 0 |_`-.
 .      \_____________.-------._______________)
 .                   /       /
 .                  /      /
 .                 /     /==)
 .                ._____."""
 
+# Git branch name used to run bisect try jobs.
+BISECT_TRYJOB_BRANCH = 'bisect-tryjob'
+# Git master branch name.
+BISECT_MASTER_BRANCH = 'master'
+# File to store 'git diff' content.
+BISECT_PATCH_FILE = 'deps_patch.txt'
+# SVN repo where the bisect try jobs are submitted.
+SVN_REPO_URL = 'svn://svn.chromium.org/chrome-try/try-perf'
+
+class RunGitError(Exception):
+
+  def __str__(self):
+    return '%s\nError executing git command.' % self.args[0]
+
 
 def _AddAdditionalDepotInfo(depot_info):
   """Adds additional depot info to the global depot variables."""
   global DEPOT_DEPS_NAME
   global DEPOT_NAMES
   DEPOT_DEPS_NAME = dict(DEPOT_DEPS_NAME.items() + depot_info.items())
   DEPOT_NAMES = DEPOT_DEPS_NAME.keys()
 
 
 def GetSHA1HexDigest(contents):
@@ skipping 576 matching lines @@
                      'was added without proper support?' % depot_name)
 
   def ChangeToDepotDir(self, depot_name):
     """Given a depot, changes to the appropriate working directory.
 
     Args:
       depot_name: The name of the depot (see DEPOT_NAMES).
     """
     os.chdir(self.GetDepotDir(depot_name))
 
+def _PrepareBisectBranch(parent_branch, new_branch):
+  """Creates a new branch to submit bisect try job.
+
+  Args:
+    parent_branch: Parent branch to be used to create new branch.
+    new_branch: New branch name.
+
+  Returns:
+    True if new branch is created succesfully, otherwise raises RunGitError
+    exception.

[qyearsley, 2014/09/27 01:45:33]

No need to return anything if the lack of an exception indicates success.

[prasadv, 2014/09/29 17:36:13]

Done.

+  """
+  current_branch, returncode = bisect_utils.RunGit(
+      ['rev-parse', '--abbrev-ref', 'HEAD'])
+  if returncode:
+    raise RunGitError('Must be in a git repository to send changes to trybots.')
+
+  current_branch = current_branch.strip()
+  # Make sure current branch is master.
+  if current_branch != parent_branch:
+    output, returncode = bisect_utils.RunGit(['checkout', '-f', parent_branch])
+    if returncode:
+      raise RunGitError('Failed to checkout branch: %s.' % output)
+
+  # Delete new branch if exists.
+  output, returncode = bisect_utils.RunGit(['branch', '--list' ])
+  if new_branch in output:
+    output, returncode = bisect_utils.RunGit(['branch', '-D', new_branch])
+    if returncode:
+      raise RunGitError('Deleting branch failed, %s', output)
+
+  # Check if the tree is dirty: make sure the index is up to date and then
+  # run diff-index

[qyearsley, 2014/09/27 01:45:33]

Nit: should add a period at the end of the sentence.
Also, below we're running "git diff-index HEAD", not just "diff-index". What
does "git diff-index HEAD" do? I guess it outputs the changes that are staged
for commit but haven't yet been committed?

Maybe these few lines could be extracted to a IsGitTreeDirty function?

[prasadv, 2014/09/29 17:36:13]

Correct it lists if we have any uncommitted changes. 
Not sure, we want to extract a new method  IsGitTreeDirty(), since it is used
only here.
Let me know if you still want to it.

On 2014/09/27 01:45:33, qyearsley wrote:

+  bisect_utils.RunGit(['update-index', '--refresh', '-q'])
+  output, returncode = bisect_utils.RunGit(['diff-index', 'HEAD'])
+  if output:
+    raise RunGitError('Cannot send a try job with a dirty tree.')
+
+  # Create/check out the telemetry-tryjob branch, and edit the configs
+  # for the tryjob there.
+  output, returncode = bisect_utils.RunGit(['checkout', '-b', new_branch])
+  if returncode:
+    raise RunGitError('Failed to checkout branch: %s.' % output)
+
+  output, returncode = bisect_utils.RunGit(
+      ['branch', '--set-upstream-to', parent_branch])
+  if returncode:
+    raise RunGitError('Error in git branch --set-upstream-to')
+
+  return True
+
+
+def _BuilderTryjob(git_revision, bot_name, bisect_job_name, patch=None):
+  """Attempts to run a tryjob from the current directory.
+
+  Args:
+    git_revision: A Git hash revision.
+    bot_name: Name of the bisect bot to be used for try job.
+    bisect_job_name: Bisect try job name.
+    patch: A DEPS patch (used while bisecting 3rd party repositories).
+
+  Returns:
+    True if a tryjob was sent otherwise raises RunGitError exception.
+  """
+  if not patch:
+    raise RunGitError('No associated patch to try')
+
+  try:
+    # Temporary branch for running tryjob.
+    _PrepareBisectBranch(BISECT_MASTER_BRANCH, BISECT_TRYJOB_BRANCH)
+    patch_content = '/dev/null'
+    # Create a temporary patch file, if it fails raise an exception.
+    if patch:
+      WriteStringToFile(patch, BISECT_PATCH_FILE)
+      patch_content = BISECT_PATCH_FILE
+
+    try_cmd = ['try',
+               '-b', bot_name,
+               '-r', git_revision,
+               '-n', bisect_job_name,
+               '--svn_repo=%s' % SVN_REPO_URL,
+               '--diff=%s' % patch_content
+              ]
+    # Execute try job to build revision.
+    output, returncode = bisect_utils.RunGit(try_cmd)
+
+    if returncode:
+      raise RunGitError('Could not execute tryjob: %s.\n Error: %s' % (
+                         'git %s' % ' '.join(try_cmd), output))
+    print ('Try job successfully submitted.\n TryJob Details: %s\n%s' % (
+           'git %s' % ' '.join(try_cmd), output))
+
+  finally:
+    # Delete patch file if exists
+    try:
+      os.remove(BISECT_PATCH_FILE)
+    except OSError as e:
+      if e.errno != errno.ENOENT:
+        raise
+    # Checkout master branch and delete bisect-tryjob branch.
+    bisect_utils.RunGit(['checkout', '-f', BISECT_MASTER_BRANCH])
+    bisect_utils.RunGit(['branch', '-D', BISECT_TRYJOB_BRANCH])
+
+  return True
+
 
 class BisectPerformanceMetrics(object):
   """This class contains functionality to perform a bisection of a range of
   revisions to narrow down where performance regressions may have occurred.
 
   The main entry-point is the Run method.
   """
 
   def __init__(self, source_control, opts):
     super(BisectPerformanceMetrics, self).__init__()
@@ skipping 316 matching lines @@
     if not downloaded_archive:
       # Get commit position for the given SHA.
       commit_position = self.source_control.GetCommitPosition(revision)
       if commit_position:
         # Source archive file path on cloud storage using SVN revision.
         source_file = GetRemoteBuildPath(
             commit_position, self.opts.target_platform, target_arch, patch_sha)
         return FetchFromCloudStorage(gs_bucket, source_file, out_dir)
     return downloaded_archive
 
-  def DownloadCurrentBuild(self, revision, build_type='Release', patch=None):
+  def DownloadCurrentBuild(self, revision, depot, build_type='Release'):
     """Downloads the build archive for the given revision.
 
     Args:
       revision: The Git revision to download or build.
       build_type: Target build type ('Release', 'Debug', 'Release_x64' etc.)
       patch: A DEPS patch (used while bisecting 3rd party repositories).
 
     Returns:
       True if download succeeds, otherwise False.
     """
+    patch = None
     patch_sha = None
+    if depot != 'chromium':
+      # Create a DEPS patch with new revision for dependency repository.
+      revision, patch = self.CreateDEPSPatch(depot, revision)
+
     if patch:
       # Get the SHA of the DEPS changes patch.
       patch_sha = GetSHA1HexDigest(patch)
 
       # Update the DEPS changes patch with a patch to create a new file named
       # 'DEPS.sha' and add patch_sha evaluated above to it.
       patch = '%s\n%s' % (patch, DEPS_SHA_PATCH % {'deps_sha': patch_sha})
 
     # Get Build output directory
     abs_build_dir = os.path.abspath(
@@ skipping 76 matching lines @@
       if bisect_utils.IsLinuxHost():
         if target_platform == 'android':
           return ('android_perf_bisect_builder', MAX_LINUX_BUILD_TIME)
         return ('linux_perf_bisect_builder', MAX_LINUX_BUILD_TIME)
       if bisect_utils.IsMacHost():
         return ('mac_perf_bisect_builder', MAX_MAC_BUILD_TIME)
       raise NotImplementedError('Unsupported Platform "%s".' % sys.platform)
     if not fetch_build:
       return False
 
-    bot_name, build_timeout = GetBuilderNameAndBuildTime(
-       self.opts.target_platform, self.opts.target_arch)
-    builder_host = self.opts.builder_host
-    builder_port = self.opts.builder_port
     # Create a unique ID for each build request posted to try server builders.
     # This ID is added to "Reason" property of the build.
     build_request_id = GetSHA1HexDigest(
         '%s-%s-%s' % (git_revision, patch, time.time()))
 
-    # Creates a try job description.
-    # Always use Git hash to post build request since Commit positions are
-    # not supported by builders to build.
-    job_args = {
-        'revision': 'src@%s' % git_revision,
-        'bot': bot_name,
-        'name': build_request_id,
-    }
-    # Update patch information if supplied.
-    if patch:
-      job_args['patch'] = patch
-    # Posts job to build the revision on the server.
-    if request_build.PostTryJob(builder_host, builder_port, job_args):
+    # Reverts any changes to DEPS file.
+    self.source_control.CheckoutFileAtRevision(
+      bisect_utils.FILE_DEPS, git_revision, cwd=self.src_cwd)
+
+    bot_name, build_timeout = GetBuilderNameAndBuildTime(
+       self.opts.target_platform, self.opts.target_arch)
+    target_file = None
+    try:
+      # Execute try job request to build revision with patch.
+      _BuilderTryjob(git_revision, bot_name, build_request_id, patch)
       target_file, error_msg = _WaitUntilBuildIsReady(
-          fetch_build, bot_name, builder_host, builder_port, build_request_id,
-          build_timeout)
+          fetch_build, bot_name, self.opts.builder_host,
+          self.opts.builder_port, build_request_id, build_timeout)
       if not target_file:
         print '%s [revision: %s]' % (error_msg, git_revision)
-        return None
-      return target_file
-    print 'Failed to post build request for revision: [%s]' % git_revision
-    return None
+    except RunGitError, e:

[qyearsley, 2014/09/27 01:45:33]

The style guide suggests using "as", e.g. "except RunGitError as e".
https://google-styleguide.googlecode.com/svn/trunk/pyguide.html?showone=Excep...

+      print ('Failed to post builder try job for revision: [%s].\n'
+             'Error: %s' % (git_revision, e))
+
+    return target_file
 
   def IsDownloadable(self, depot):
     """Checks if build can be downloaded based on target platform and depot."""
     if (self.opts.target_platform in ['chromium', 'android'] and
         self.opts.gs_bucket):
       return (depot == 'chromium' or
               'chromium' in DEPOT_DEPS_NAME[depot]['from'] or
               'v8' in DEPOT_DEPS_NAME[depot]['from'])
     return False
 
@@ skipping 76 matching lines @@
       updated_deps_content = self.UpdateDepsContents(
           deps_contents, depot, revision, deps_var)
       # Write changes to DEPS file
       if updated_deps_content:
         WriteStringToFile(updated_deps_content, deps_file)
         return True
     except IOError, e:
       print 'Something went wrong while updating DEPS file. [%s]' % e
     return False
 
+
   def CreateDEPSPatch(self, depot, revision):
     """Modifies DEPS and returns diff as text.
 
     Args:
       depot: Current depot being bisected.
       revision: A git hash revision of the dependency repository.
 
     Returns:
       A tuple with git hash of chromium revision and DEPS patch text.
     """
     deps_file_path = os.path.join(self.src_cwd, bisect_utils.FILE_DEPS)
     if not os.path.exists(deps_file_path):
       raise RuntimeError('DEPS file does not exists.[%s]' % deps_file_path)
     # Get current chromium revision (git hash).
     cmd = ['rev-parse', 'HEAD']
     chromium_sha = bisect_utils.CheckRunGit(cmd).strip()
     if not chromium_sha:
       raise RuntimeError('Failed to determine Chromium revision for %s' %
                          revision)
     if ('chromium' in DEPOT_DEPS_NAME[depot]['from'] or
         'v8' in DEPOT_DEPS_NAME[depot]['from']):
       # Checkout DEPS file for the current chromium revision.
       if self.source_control.CheckoutFileAtRevision(
           bisect_utils.FILE_DEPS, chromium_sha, cwd=self.src_cwd):
         if self.UpdateDeps(revision, depot, deps_file_path):
           diff_command = [
               'diff',
-              '--src-prefix=src/',
-              '--dst-prefix=src/',
+              '--src-prefix=',
+              '--dst-prefix=',
               '--no-ext-diff',
                bisect_utils.FILE_DEPS,
           ]
           diff_text = bisect_utils.CheckRunGit(diff_command, cwd=self.src_cwd)
           return (chromium_sha, ChangeBackslashToSlashInPatch(diff_text))
         else:
           raise RuntimeError(
               'Failed to update DEPS file for chromium: [%s]' % chromium_sha)
       else:
         raise RuntimeError(
             'DEPS checkout Failed for chromium revision : [%s]' % chromium_sha)
     return (None, None)
 
   def BuildCurrentRevision(self, depot, revision=None):
     """Builds chrome and performance_ui_tests on the current revision.
 
     Returns:
       True if the build was successful.
     """
     if self.opts.debug_ignore_build:
       return True
 
     build_success = False
     cwd = os.getcwd()
     os.chdir(self.src_cwd)
     # Fetch build archive for the given revision from the cloud storage when
     # the storage bucket is passed.
     if self.IsDownloadable(depot) and revision:
-      deps_patch = None
-      if depot != 'chromium':
-        # Create a DEPS patch with new revision for dependency repository.
-        revision, deps_patch = self.CreateDEPSPatch(depot, revision)
-      if self.DownloadCurrentBuild(revision, patch=deps_patch):
-        if deps_patch:
-          # Reverts the changes to DEPS file.
-          self.source_control.CheckoutFileAtRevision(
-              bisect_utils.FILE_DEPS, revision, cwd=self.src_cwd)
-        build_success = True
+      build_success = self.DownloadCurrentBuild(revision, depot)
     else:
       # These codes are executed when bisect bots builds binaries locally.
       build_success = self.builder.Build(depot, self.opts)
     os.chdir(cwd)
     return build_success
 
   def RunGClientHooks(self):
     """Runs gclient with runhooks command.
 
     Returns:
@@ skipping 275 matching lines @@
 
   def _PerformPreSyncCleanup(self, depot):
     """Performs any necessary cleanup before syncing.
 
     Args:
       depot: Depot name.
 
     Returns:
       True if successful.
     """
-    if depot == 'chromium' or depot == 'android-chrome':
-      # Removes third_party/libjingle. At some point, libjingle was causing
-      # issues syncing when using the git workflow (crbug.com/266324).
-      os.chdir(self.src_cwd)
-      if not bisect_utils.RemoveThirdPartyDirectory('libjingle'):
-        return False
-      # Removes third_party/skia. At some point, skia was causing
-      # issues syncing when using the git workflow (crbug.com/377951).
-      if not bisect_utils.RemoveThirdPartyDirectory('skia'):
-        return False
-    elif depot == 'cros':
+    if depot == 'cros':
       return self.PerformCrosChrootCleanup()
     return True
 
   def _RunPostSync(self, depot):
     """Performs any work after syncing.
 
     Args:
       depot: Depot name.
 
     Returns:
@@ skipping 1364 matching lines @@
       # bugs. If you change this, please update the perf dashboard as well.
       bisect_utils.OutputAnnotationStepStart('Results')
     print 'Error: %s' % e.message
     if opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
   return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())