Fix checkout root detection for git

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 errno
 import getpass
 import logging
 import optparse
 import os
 import posixpath
 import shutil
-import socket
-import subprocess
 import sys
 import tempfile
 import urllib
 
 try:
   import breakpad
 except ImportError:
   pass
 
 import gclient_utils
@@ skipping 84 matching lines @@
       'root': self.GetCodeReviewSetting('TRYSERVER_ROOT'),
       'patchlevel': self.GetCodeReviewSetting('TRYSERVER_PATCHLEVEL'),
     }
     for (k, v) in settings.iteritems():
       if v and getattr(self.options, k) is None:
         setattr(self.options, k, v)
 
   def GclientStyleSettings(self):
     """Find the root, assuming a gclient-style checkout."""
     if not self.options.no_gclient and not self.options.root:
-      root = self.GetLocalRoot()
+      root = self.checkout_root
       gclient_root = gclient_utils.FindGclientRoot(root)
       if gclient_root:
         self.options.root = gclient_utils.PathDifference(gclient_root, root)
 
   def AutomagicalSettings(self):
     """Determines settings based on supported code review and checkout tools.
     """
     self.GclStyleSettings()
     self.GclientStyleSettings()
 
+  def ReadRootFile(self, filename):
+    raise NotImplementedError()
+
 
 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):
     try:
       # Try to search on the subversion repository for the file.
       import gcl
       data = gcl.GetCachedFile(filename, use_root=True)
       logging.debug('%s:\n%s' % (filename, data))
       return data
     except ImportError:
       try:
@@ skipping 15 matching lines @@
       previous_cwd = os.getcwd()
       os.chdir(self.checkout_root)
       excluded = ['!', '?', 'X', ' ', '~']
       self.files = [
           f[1] for f in scm.SVN.CaptureStatus(self.checkout_root)
           if f[0][0] not in excluded
       ]
       os.chdir(previous_cwd)
     return scm.SVN.GenerateDiff(self.files, self.checkout_root, full_move=True)
 
-  def GetLocalRoot(self):
-    """Return the path of the repository root."""
-    return self.checkout_root
-
 
 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)
+    logging.info("GIT(%s)" % self.checkout_root)
 
   def ReadRootFile(self, filename):
     try:
       # A git checkout is always a full checkout.
       data = gclient_utils.FileRead(os.path.join(self.checkout_root, filename))
       logging.debug('%s:\n%s' % (filename, data))
       return data
     except (IOError, OSError):
       logging.debug('%s:\nNone' % filename)
       return None
 
-  def GetLocalRoot(self):
-    """Return the path of the repository root."""
-    return self.checkout_root
-
   def GenerateDiff(self):
     # For now, ignores self.files
     return scm.GIT.GenerateDiff(self.checkout_root, full_move=True)
 
 
 def _ParseSendChangeOptions(options):
   """Parse common options passed to _SendChangeHTTP and _SendChangeSVN."""
   values = {}
   if options.email:
     values['email'] = options.email
@@ skipping 131 matching lines @@
 
 
 def PrintSuccess(options):
   if not options.dry_run:
     text = 'Patch \'%s\' sent to try server' % options.name
     if options.bot:
       text += ': %s' % ', '.join(options.bot)
     print(text)
 
 
-def GuessVCS(options, cwd):
+def GuessVCS(options, path):
   """Helper to guess the version control system.
 
   NOTE: Very similar to upload.GuessVCS. Doesn't look for hg since we don't
   support it yet.
 
-  This examines the current directory, guesses which SCM we're using, and
+  This examines the path directory, guesses which SCM we're using, and
   returns an instance of the appropriate class.  Exit with an error if we can't
   figure it out.
 
   Returns:
     A SCM instance. Exits if the SCM can't be guessed.
   """
   __pychecker__ = 'no-returnvalues'
+  logging.info("GuessVCS(%s)" % path)
   # Subversion has a .svn in all working directories.
-  if os.path.isdir(os.path.join(cwd, '.svn')):
-    logging.info("GuessVCS(%s) = Subversion" % cwd)
-    return SVN(options, cwd)
+  if os.path.isdir(os.path.join(path, '.svn')):
+    return SVN(options, path)
 
   # Git has a command to test if you're in a git tree.
   # Try running it, but don't die if we don't have git installed.
   try:
-    gclient_utils.CheckCall(["git", "rev-parse", "--is-inside-work-tree"], cwd)
-    logging.info("GuessVCS(%s) = Git" % cwd)
-    return GIT(options, cwd)
+    gclient_utils.CheckCall(["git", "rev-parse", "--is-inside-work-tree"],
+                            path)
+    return GIT(options, path)
   except gclient_utils.CheckCallError, e:
-    if e.retcode != 2:  # ENOENT -- they don't have git installed.
+    if e.retcode != errno.ENOENT and e.retcode != 128:
+      # ENOENT == 2 = they don't have git installed.
+      # 128 = git error code when not in a repo.
+      logging.warn(e.retcode)
       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):
   """
@@ skipping 59 matching lines @@
                    metavar="FILE", action="append",
                    help="Use many times to list the files to include in the "
                         "try, relative to the repository root")
   group.add_option("--diff",
                    help="File containing the diff to try")
   group.add_option("--url",
                    help="Url where to grab a patch")
   group.add_option("--root",
                    help="Root to use for the patch; base subdirectory for "
                         "patch created in a subdirectory")
-  group.add_option("--patchlevel", type='int', metavar="LEVEL",
+  group.add_option("-p", "--patchlevel", type='int', metavar="LEVEL",
                    help="Used as -pN parameter to patch")
-  group.add_option("--sub_rep", action="append", default=[],
+  group.add_option("-s", "--sub_rep", action="append", default=[],
                    help="Subcheckout to use in addition. This is mainly "
                         "useful for gclient-style checkouts.")
   group.add_option("--no_gclient", action="store_true",
                    help="Disable automatic search for gclient checkout.")
   parser.add_option_group(group)
 
   group = optparse.OptionGroup(parser, "Access the try server by HTTP")
   group.add_option("--use_http",
                    action="store_const",
                    const=_SendChangeHTTP,
                    dest="send_patch",
                    help="Use HTTP to talk to the try server [default]")
-  group.add_option("--host",
+  group.add_option("-H", "--host",
                    help="Host address")
-  group.add_option("--port",
+  group.add_option("-P", "--port",
                    help="HTTP port")
   group.add_option("--proxy",
                    help="HTTP proxy")
   parser.add_option_group(group)
 
   group = optparse.OptionGroup(parser, "Access the try server with SVN")
   group.add_option("--use_svn",
                    action="store_const",
                    const=_SendChangeSVN,
                    dest="send_patch",
                    help="Use SVN to talk to the try server")
-  group.add_option("--svn_repo",
+  group.add_option("-S", "--svn_repo",
                    metavar="SVN_URL",
                    help="SVN url to use to write the changes in; --use_svn is "
                         "implied when using --svn_repo")
   parser.add_option_group(group)
 
   options, args = parser.parse_args(argv)
   if len(args) == 1 and args[0] == 'help':
     parser.print_help()
 
-  if options.verbose == 0:
-    logging.basicConfig(level=logging.ERROR)
-  elif options.verbose == 1:
-    logging.basicConfig(level=logging.WARNING)
-  elif options.verbose == 2:
-    logging.basicConfig(level=logging.INFO)
-  elif options.verbose > 2:
-    logging.basicConfig(level=logging.DEBUG)
+  if not swallow_exception:
+    if options.verbose == 0:
+      logging.basicConfig(level=logging.ERROR)
+    elif options.verbose == 1:
+      logging.basicConfig(level=logging.WARNING)
+    elif options.verbose == 2:
+      logging.basicConfig(level=logging.INFO)
+    elif options.verbose > 2:
+      logging.basicConfig(level=logging.DEBUG)
 
   try:
     # Always include os.getcwd() in the checkout settings.
     checkouts = []
     checkouts.append(GuessVCS(options, os.getcwd()))
     checkouts[0].AutomagicalSettings()
     for item in options.sub_rep:
-      checkout = GuessVCS(options, item)
-      if checkout.GetLocalRoot() in [c.GetLocalRoot() for c in checkouts]:
+      checkout = GuessVCS(options, os.path.join(checkouts[0].checkout_root,
+                                                item))
+      if checkout.checkout_root in [c.checkout_root for c in checkouts]:
         parser.error('Specified the root %s two times.' %
-                     checkout.GetLocalRoot())
+                     checkout.checkout_root)
       checkouts.append(checkout)
 
     can_http = options.port and options.host
     can_svn = options.svn_repo
     # If there was no transport selected yet, now we must have enough data to
     # select one.
     if not options.send_patch and not (can_http or can_svn):
       parser.error('Please specify an access method.')
 
     # Convert options.diff into the content of the diff.
     if options.url:
       if options.files:
         parser.error('You cannot specify files and --url at the same time.')
       options.diff = urllib.urlopen(options.url).read()
     elif options.diff:
       if options.files:
         parser.error('You cannot specify files and --diff at the same time.')
       options.diff = gclient_utils.FileRead(options.diff, 'rb')
     else:
       # Use this as the base.
-      root = checkouts[0].GetLocalRoot()
+      root = checkouts[0].checkout_root
       diffs = []
       for checkout in checkouts:
         diff = checkout.GenerateDiff().splitlines(True)
         # Munge it.
-        path_diff = gclient_utils.PathDifference(root, checkout.GetLocalRoot())
+        path_diff = gclient_utils.PathDifference(root, checkout.checkout_root)
         for i in range(len(diff)):
           if diff[i].startswith('--- ') or diff[i].startswith('+++ '):
             diff[i] = diff[i][0:4] + posixpath.join(path_diff, diff[i][4:])
         diffs.extend(diff)
       options.diff = ''.join(diffs)
 
     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')
         options.bot = presubmit_support.DoGetTrySlaves(
             checkouts[0].GetFileNames(),
-            checkouts[0].GetLocalRoot(),
+            checkouts[0].checkout_root,
             root_presubmit,
             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:
@@ skipping 27 matching lines @@
   except (InvalidScript, NoTryServerAccess), e:
     if swallow_exception:
       return 1
     print e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   sys.exit(TryChange(None, [], False))