Make the try slave selection client side.

trychange.py

 #!/usr/bin/python
 # Copyright (c) 2009 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.
 """Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn repository or by directly connecting
 to the server by HTTP.
 """
 
 
 import datetime
 import getpass
 import logging
 import optparse
 import os
 import shutil
 import socket
 import subprocess
 import sys
 import tempfile
 import traceback
 import urllib
 
 import gcl
 import gclient
 import gclient_scm
+import presubmit_support
 import upload
 
 __version__ = '1.1.1'
 
 
 # Constants
 HELP_STRING = "Sorry, Tryserver is not available."
 USAGE = r"""%prog [options]
 
 Client-side script to send a try job to the try server. It communicates to
@@ skipping 151 matching lines @@
                  "======\n")
         # Note: Should we use /dev/null instead?
         data += "--- %s\n" % file
         data += "+++ %s\n" % file
         data += "@@ -0,0 +1,%d @@\n" % nb_lines
         data += ''.join(file_content)
       diff.append(data)
     os.chdir(previous_cwd)
     return "".join(diff)
 
+  def GetFileNames(self):
+    """Return the list of files in the diff."""
+    return self.change_info.GetFileNames()
+
+  def GetLocalRoot(self):
+    """Return the path of the repository root."""
+    return self.change_info.GetLocalRoot()
+
   def ProcessOptions(self):
     if not self.options.diff:
       # Generate the diff with svn and write it to the submit queue path.  The
       # files are relative to the repository root, but we need patches relative
       # to one level up from there (i.e., 'src'), so adjust both the file
       # paths and the root of the diff.
       source_root = GetSourceRoot()
       prefix = PathDifference(source_root, gcl.GetRepositoryRoot())
       adjusted_paths = [os.path.join(prefix, x) for x in self.options.files]
       self.options.diff = self.GenerateDiff(adjusted_paths, root=source_root)
+      self.change_info = gcl.LoadChangelistInfoForMultiple(self.options.name,
+          gcl.GetRepositoryRoot(), True, True)
 
 
 class GIT(SCM):
   """Gathers the options and diff for a git checkout."""
   def GenerateDiff(self):
     """Get the diff we'll send to the try server. We ignore the files list."""
     branch = upload.RunShell(['git', 'cl', 'upstream']).strip()
     diff = upload.RunShell(['git', 'diff-tree', '-p', '--no-prefix',
                             branch, 'HEAD']).splitlines(True)
     for i in range(len(diff)):
       # In the case of added files, replace /dev/null with the path to the
       # file being added.
       if diff[i].startswith('--- /dev/null'):
         diff[i] = '--- %s' % diff[i+1][4:]
     return ''.join(diff)
 
   def GetEmail(self):
     # TODO: check for errors here?
     return upload.RunShell(['git', 'config', 'user.email']).strip()
 
+  def GetFileNames(self):
+    """Return the list of files in the diff."""
+    return self.options.files
+
+  def GetLocalRoot(self):
+    """Return the path of the repository root."""
+    # TODO: check for errors here?
+    root = upload.RunShell(['git', 'rev-parse', '--show-cdup']).strip()
+    return os.path.abspath(root)
+
   def GetPatchName(self):
     """Construct a name for this patch."""
     # TODO: perhaps include the hash of the current commit, to distinguish
     # patches?
     branch = upload.RunShell(['git', 'symbolic-ref', 'HEAD']).strip()
     if not branch.startswith('refs/heads/'):
       raise "Couldn't figure out branch name"
     branch = branch[len('refs/heads/'):]
     return branch
 
@@ skipping 165 matching lines @@
       raise
 
   raise NoTryServerAccess("Could not guess version control system. "
                           "Are you in a working copy directory?")
 
 
 def TryChange(argv,
               file_list,
               swallow_exception,
               prog=None):
+  """
+  Args:
+    argv: Arguments and options.
+    file_list: Default value to pass to --file.
+    swallow_exception: Whether we raise or swallow exceptions.
+  """
   default_settings = GetTryServerSettings()
   transport_functions = { 'http': _SendChangeHTTP, 'svn': _SendChangeSVN }
   default_transport = transport_functions.get(
       default_settings.get('default_transport'))
 
   # Parse argv
   parser = optparse.OptionParser(usage=USAGE,
                                  version=__version__,
                                  prog=prog)
 
@@ skipping 112 matching lines @@
       options.diff = gcl.ReadFile(options.diff)
     # Process the VCS in any case at least to retrieve the email address.
     try:
       options.scm = GuessVCS(options)
       options.scm.ProcessOptions()
     except NoTryServerAccess, e:
       # If we got the diff, we don't care.
       if not options.diff:
         raise
 
+    # Get try slaves from PRESUBMIT.py files if not specified.
+    if not options.bot:
+      root_presubmit = gcl.GetCachedFile('PRESUBMIT.py', use_root=True)
+      options.bot = presubmit_support.DoGetTrySlaves(options.scm.GetFileNames(),
+                                                     options.scm.GetLocalRoot(),
+                                                     root_presubmit,
+                                                     False,
+                                                     sys.stdout)
+
     # Send the patch.
     patch_name = options.send_patch(options)
-    print 'Patch \'%s\' sent to try server.' % patch_name
+    print 'Patch \'%s\' sent to try server: %s' % (patch_name,
+                                                   ', '.join(options.bot))
     if patch_name == 'Unnamed':
       print "Note: use --name NAME to change the try's name."
   except (InvalidScript, NoTryServerAccess), e:
     if swallow_exception:
       return
     print e
 
 
 if __name__ == "__main__":
   TryChange(None, None, False)