Support for |change| argument to |GetPreferredTrySlaves()|, try 2.

trychange.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 """
 
@@ skipping 82 matching lines @@
 
 class SCM(object):
   """Simplistic base class to implement one function: ProcessOptions."""
   def __init__(self, options, path):
     items = path.split('@')
     assert len(items) <= 2
     self.checkout_root = items[0]
     items.append(None)
     self.diff_against = items[1]
     self.options = options
-    self.files = self.options.files
+    # Lazy-load file list from the SCM unless files were specified in options.
+    self._files = None
+    self._file_tuples = None
+    if self.options.files != []:

[M-A Ruel, 2011/09/27 14:13:00]

if self.options.files:
?

[Alexei Svitkine (slow), 2011/09/27 14:21:01]

Done.

+      self._files = self.options.files
+      self._file_tuples = [('M', f) for f in self.files]
     self.options.files = None
     self.codereview_settings = None
     self.codereview_settings_file = 'codereview.settings'
     self.gclient_root = None
 
   def GetFileNames(self):
     """Return the list of files in the diff."""
     return self.files
 
   def GetCodeReviewSetting(self, key):
@@ skipping 66 matching lines @@
     assert cur.startswith(root), (root, cur)
     while cur.startswith(root):
       filepath = os.path.join(cur, filename)
       if os.path.isfile(filepath):
         logging.info('Found %s at %s' % (filename, cur))
         return gclient_utils.FileRead(filepath)
       cur = os.path.dirname(cur)
     logging.warning('Didn\'t find %s' % filename)
     return None
 
+  def _SetFileTuples(self, file_tuples):
+    excluded = ['!', '?', 'X', ' ', '~']
+    def Excluded(f):
+      if f[0][0] in excluded:
+        return True
+      for r in self.options.exclude:
+        if re.search(r, f[1]):
+          logging.info('Ignoring "%s"' % f[1])
+          return True
+      return False
+
+    self._file_tuples = [f for f in file_tuples if not Excluded(f)]
+    self._files = [f[1] for f in self._file_tuples]
+
+  def CaptureStatus(self):
+    """Returns the 'svn status' emulated output as an array of (status, file)
+       tuples."""
+    raise NotImplementedError(
+        "abstract method -- subclass %s must override" % self.__class__)
+
+  @property
+  def files(self):
+    if self._files is None:
+      self._SetFileTuples(self.CaptureStatus())
+    return self._files
+
+  @property
+  def file_tuples(self):
+    if self._file_tuples is None:
+      self._SetFileTuples(self.CaptureStatus())
+    return self._file_tuples
+
 
 class SVN(SCM):
   """Gathers the options and diff for a subversion checkout."""
   def __init__(self, *args, **kwargs):
     SCM.__init__(self, *args, **kwargs)
     self.checkout_root = scm.SVN.GetCheckoutRoot(self.checkout_root)
     if not self.options.email:
       # Assumes the svn credential is an email address.
       self.options.email = scm.SVN.GetEmail(self.checkout_root)
     logging.info("SVN(%s)" % self.checkout_root)
 
   def ReadRootFile(self, filename):
     data = SCM.ReadRootFile(self, filename)
     if data:
       return data
 
     # Try to search on the subversion repository for the file.
     if not gcl:
       return None
     data = gcl.GetCachedFile(filename)
     logging.debug('%s:\n%s' % (filename, data))
     return data
 
+  def CaptureStatus(self):
+    previous_cwd = os.getcwd()
+    os.chdir(self.checkout_root)
+    result = scm.SVN.CaptureStatus(self.checkout_root)
+    os.chdir(previous_cwd)
+    return result
+
   def GenerateDiff(self):
     """Returns a string containing the diff for the given file list.
 
     The files in the list should either be absolute paths or relative to the
     given root.
     """
-    if not self.files:
-      previous_cwd = os.getcwd()
-      os.chdir(self.checkout_root)
-
-      excluded = ['!', '?', 'X', ' ', '~']
-      def Excluded(f):
-        if f[0][0] in excluded:
-          return True
-        for r in self.options.exclude:
-          if re.search(r, f[1]):
-            logging.info('Ignoring "%s"' % f[1])
-            return True
-        return False
-
-      self.files = [f[1] for f in scm.SVN.CaptureStatus(self.checkout_root)
-                    if not Excluded(f)]
-      os.chdir(previous_cwd)
     return scm.SVN.GenerateDiff(self.files, self.checkout_root, full_move=True,
                                 revision=self.diff_against)
 
 
 class GIT(SCM):
   """Gathers the options and diff for a git checkout."""
   def __init__(self, *args, **kwargs):
     SCM.__init__(self, *args, **kwargs)
     self.checkout_root = scm.GIT.GetCheckoutRoot(self.checkout_root)
     if not self.options.name:
       self.options.name = scm.GIT.GetPatchName(self.checkout_root)
     if not self.options.email:
       self.options.email = scm.GIT.GetEmail(self.checkout_root)
     if not self.diff_against:
       self.diff_against = scm.GIT.GetUpstreamBranch(self.checkout_root)
       if not self.diff_against:
         raise NoTryServerAccess(
             "Unable to determine default branch to diff against. "
             "Verify this branch is set up to track another"
             "(via the --track argument to \"git checkout -b ...\"")
     logging.info("GIT(%s)" % self.checkout_root)
 
+  def CaptureStatus(self):
+    return scm.GIT.CaptureStatus(self.checkout_root, self.diff_against)
+
   def GenerateDiff(self):
-    if not self.files:
-      self.files = scm.GIT.GetDifferentFiles(self.checkout_root,
-                                             branch=self.diff_against)
-
-    def NotExcluded(f):
-      for r in self.options.exclude:
-        if re.search(r, f):
-          logging.info('Ignoring "%s"' % f)
-          return False
-      return True
-
-    self.files = filter(NotExcluded, self.files)
     return scm.GIT.GenerateDiff(self.checkout_root, files=self.files,
                                 full_move=True,
                                 branch=self.diff_against)
 
 
 def _ParseSendChangeOptions(options):
   """Parse common options passed to _SendChangeHTTP and _SendChangeSVN."""
   values = {}
   if options.email:
     values['email'] = options.email
@@ skipping 176 matching lines @@
 def GetMungedDiff(path_diff, diff):
   # Munge paths to match svn.
   for i in range(len(diff)):
     if diff[i].startswith('--- ') or diff[i].startswith('+++ '):
       new_file = posixpath.join(path_diff, diff[i][4:]).replace('\\', '/')
       diff[i] = diff[i][0:4] + new_file
   return diff
 
 
 def TryChange(argv,
+              change,
               file_list,
               swallow_exception,
               prog=None,
               extra_epilog=None):
   """
   Args:
     argv: Arguments and options.
     file_list: Default value to pass to --file.
     swallow_exception: Whether we raise or swallow exceptions.
   """
@@ skipping 217 matching lines @@
       # Use this as the base.
       root = checkouts[0].checkout_root
       diffs = []
       for checkout in checkouts:
         diff = checkout.GenerateDiff().splitlines(True)
         path_diff = gclient_utils.PathDifference(root, checkout.checkout_root)
         # Munge it.
         diffs.extend(GetMungedDiff(path_diff, diff))
       options.diff = ''.join(diffs)
 
+    if not options.name:
+      if options.issue:
+        options.name = 'Issue %s' % options.issue
+      else:
+        options.name = 'Unnamed'
+        print('Note: use --name NAME to change the try job name.')
+
+    if not options.email:
+      parser.error('Using an anonymous checkout. Please use --email or set '
+                   'the TRYBOT_RESULTS_EMAIL_ADDRESS environment variable.')
+    print('Results will be emailed to: ' + options.email)
+
     if not options.bot:
       # Get try slaves from PRESUBMIT.py files if not specified.
       # Even if the diff comes from options.url, use the local checkout for bot
       # selection.
       try:
         import presubmit_support
         root_presubmit = checkouts[0].ReadRootFile('PRESUBMIT.py')
+        if change is None:
+          change = presubmit_support.Change(options.name,
+                                            '',
+                                            checkouts[0].checkout_root,
+                                            checkouts[0].file_tuples,
+                                            options.issue,
+                                            options.patchset,
+                                            options.email)
         options.bot = presubmit_support.DoGetTrySlaves(
+            change,
             checkouts[0].GetFileNames(),
             checkouts[0].checkout_root,
             root_presubmit,
             options.project,
             False,
             sys.stdout)
       except ImportError:
         pass
       # If no bot is specified, either the default pool will be selected or the
       # try server will refuse the job. Either case we don't need to interfere.
 
-    if options.name is None:
-      if options.issue:
-        options.name = 'Issue %s' % options.issue
-      else:
-        options.name = 'Unnamed'
-        print('Note: use --name NAME to change the try job name.')
-    if not options.email:
-      parser.error('Using an anonymous checkout. Please use --email or set '
-                   'the TRYBOT_RESULTS_EMAIL_ADDRESS environment variable.')
-    else:
-      print('Results will be emailed to: ' + options.email)
-
     # Prevent rietveld updates if we aren't running all the tests.
     if options.testfilter is not None:
       options.issue = None
       options.patchset = None
 
     # Send the patch.
     if options.send_patch:
       # If forced.
       options.send_patch(options)
       PrintSuccess(options)
@@ skipping 15 matching lines @@
     print >> sys.stderr, e
     return 1
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   fix_encoding.fix_encoding()
-  sys.exit(TryChange(None, [], False))
+  sys.exit(TryChange(None, None, [], False))