Add support for an alternate svn config directory for both svn and git-svn.

checkout.py

 # coding=utf8
 # Copyright (c) 2010 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.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 import logging
@@ skipping 32 matching lines @@
   except OSError:
     return None
   return settings.get(key, None)
 
 
 class CheckoutBase(object):
   def __init__(self, root_dir, project_name):
     self.root_dir = root_dir
     self.project_name = project_name
     self.project_path = os.path.join(self.root_dir, self.project_name)
+    self.svn_config_dir = os.path.normpath(
+        os.path.join(self.root_dir, '..', 'subversion_config'))
+    assert self.root_dir
+    assert self.project_name
+    assert self.project_path
 
   def get_settings(self, key):
     return get_code_review_setting(self.project_path, key)
 
 
 class SvnMixIn(object):
   """MixIn class to add svn commands common to both svn and git-svn clients."""
   # These members need to be set by the subclass.
   commit_user = None
   commit_pwd = None
   svn_url = None
   project_path = None
+  svn_config_dir = None
+
+  def _add_svn_flags(self, args):
+    args = ['svn'] + args + [
+        '--config-dir', self.svn_config_dir, '--non-interactive']
+    if self.commit_user:
+      args = args + [
+          '--username', self.commit_user, '--password', self.commit_pwd]
+    return args
 
   def _check_call_svn(self, args, **kwargs):
     """Runs svn and throws an exception if the command failed."""
     kwargs.setdefault('cwd', self.project_path)
-    return subprocess2.check_call(
-        ['svn'] + args + ['--no-auth-cache', '--non-interactive'], **kwargs)
+    return subprocess2.check_call(self._add_svn_flags(args), **kwargs)
 
   def _capture_svn(self, args, **kwargs):
     """Runs svn and throws an exception if the command failed.
 
      Returns the output.
     """
     kwargs.setdefault('cwd', self.project_path)
-    if self.commit_user:
-      args = args + [
-          '--username', self.commit_user, '--password', self.commit_pwd]
-    cmd = ['svn'] + args + ['--no-auth-cache', '--non-interactive']
-    return subprocess2.check_capture(cmd, **kwargs)
+    return subprocess2.check_capture(self._add_svn_flags(args), **kwargs)
 
   @staticmethod
   def _parse_svn_info(output, key):
     """Returns value for key from svn info output.
 
     Case insensitive.
     """
     values = {}
     for line in output.splitlines(False):
       if not line:
         continue
       k, v = line.split(':', 1)
       k = k.strip().lower()
       v = v.strip()
       assert not k in values
       values[k] = v
     return values.get(key, None)
 
   def _update_committer(self, revision, new_author):
     """Changes the author of a commit a posteriori.
 
     This is necessary since the actual commit is done with a "commit-bot"
     credential but the original patch author needs to be assigned authorship
     of the revision.
     """
     self._check_call_svn(
         ['propset', '--revprop', 'svn:author',
         '-r', revision,
         new_author,
-        '--username', self.commit_user,
-        '--password', self.commit_pwd,
         self.svn_url])
 
 
 class SvnCheckout(CheckoutBase, SvnMixIn):
   """Manages a subversion checkout.
 
   Commit is not fully implemented yet. Reimplementing all the commands is
   slightly complex, svn add with history needs to be done with svn
   copy/rename/move and the situation quickly becomes harder when directories are
   moved.
   """
   def __init__(self, root_dir, project_name, commit_user, commit_pwd, svn_url):
     super(SvnCheckout, self).__init__(root_dir, project_name)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     self.svn_url = svn_url
     assert bool(self.commit_user) == bool(self.commit_pwd)
-    assert bool(self.svn_url)
+    assert self.svn_url
 
   def prepare(self):
     """Creates the initial checkouts for the repo."""
     # Will checkout if the directory is not present.
     logging.info('Checking out %s in %s' %
         (self.project_name, self.project_path))
     return self._revert()
 
   def apply_patch(self, patch_data):
     """Applies a patch."""
@@ skipping 75 matching lines @@
 
 
 class GitCheckoutBase(CheckoutBase):
   """Base class for git checkout. Not to be used as-is."""
   def __init__(self, root_dir, project_name, remote_branch):
     super(GitCheckoutBase, self).__init__(root_dir, project_name)
     # There is no reason to not hardcode it.
     self.remote = 'origin'
     self.remote_branch = remote_branch
     self.working_branch = 'working_branch'
+    assert self.remote_branch
 
   def prepare(self):
     """Resets the git repository in a clean state."""
     assert os.path.isdir(self.project_path)
     self._check_call_git(['checkout', 'master', '--force'])
     self._check_call_git(['pull', self.remote, self.remote_branch])
     self._call_git(['branch', '-D', self.working_branch])
 
   def apply_patch(self, patch_data):
     """Applies a patch on 'working_branch'."""
     self._check_call_git(
         ['checkout', '-b', self.working_branch,
          '%s/%s' % (self.remote, self.remote_branch)])
     self._check_call_git(['apply', '--index', '-p0'], stdin=patch_data)
     self._check_call_git(['commit', '-m', 'Committed patch'])
 
   def commit(self, commit_message, user):
+    """Updates the commit message.
+
+    Subclass needs to dcommit or push."""
     self._check_call_git(['commit', '--amend', '-m', commit_message])
 
   def _check_call_git(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.check_call(['git'] + args, **kwargs)
 
   def _call_git(self, args, **kwargs):
     """Like check_call but doesn't throw on failure."""
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.call(['git'] + args, **kwargs)
@@ skipping 10 matching lines @@
       commit_user, commit_pwd,
       svn_url, trunk):
     """trunk is optional."""
     super(GitSvnCheckoutBase, self).__init__(
         root_dir, project_name + '.git', remote_branch)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     # svn_url in this case is the root of the svn repository.
     self.svn_url = svn_url
     self.trunk = trunk
+    assert bool(self.commit_user) == bool(self.commit_pwd)
+    assert self.svn_url
+    assert self.trunk
 
   def prepare(self):
     """Resets the git repository in a clean state."""
     self._check_call_git(['checkout', 'master', '--force'])
-    self._check_call_git(['svn', 'rebase'])
+    self._check_call_git_svn(['rebase'])
     self._call_git(['branch', '-D', self.working_branch])
     return int(self._git_svn_info('revision'))
 
   def _git_svn_info(self, key):
+    """Calls git svn info. This doesn't support nor need --config-dir."""
     return self._parse_svn_info(
         self._check_capture_git(['svn', 'info']), key)
 
   def commit(self, commit_message, user):
     """Commits a patch."""
     logging.info('Committing patch for %s' % user)
     # Fix the commit message.
     super(GitSvnCheckoutBase, self).commit(commit_message, user)
     # Commit with git svn dcommit, then use svn directly to update the
     # committer on the revision.
     self._check_call_git_svn(['dcommit', '--rmdir', '--find-copies-harder'])
     revision = int(self._git_svn_info('revision'))
     # Fix the committer.
     self._update_committer(revision, user)
     return revision
 
   def _cache_svn_auth(self):
     """Caches the svn credentials. It is necessary since git-svn doesn't prompt
     for it."""
     if not self.commit_user:
       return
     logging.info('Caching svn credentials for %s' % self.commit_user)
-    subprocess2.check_call(
-        ['svn', 'ls', self.svn_url,
-          '--username', self.commit_user,
-          '--password', self.commit_pwd,
-          '--non-interactive'])
+    self._check_call_svn(['ls', self.svn_url], cwd=None)
 
   def _check_call_git_svn(self, args, **kwargs):
     """Handles svn authentication while calling git svn."""
-    args = ['svn'] + args
-    if self.commit_user:
-      args = args + ['--username', self.commit_user, '--no-auth-cache']
-    return self._check_call_git(args, stdin=self.commit_pwd, **kwargs)
+    args = ['svn'] + args + ['--config-dir', self.svn_config_dir]
+    self._cache_svn_auth()
+    return self._check_call_git(args, **kwargs)
 
 
 class GitSvnPremadeCheckout(GitSvnCheckoutBase):
   """Manages a git-svn clone made out from an initial git-svn seed.
 
   This class is very similar to GitSvnCheckout but is faster to bootstrap
   because it starts right off with an existing git-svn clone.
   """
   def __init__(self,
       root_dir, project_name, remote_branch,
       commit_user, commit_pwd,
       svn_url, trunk, git_url):
     super(GitSvnPremadeCheckout, self).__init__(
         root_dir, project_name, remote_branch,
         commit_user, commit_pwd,
         svn_url, trunk)
     self.git_url = git_url
+    assert self.git_url
 
   def prepare(self):
     """Creates the initial checkout for the repo."""
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
       assert self.remote == 'origin'
       self._check_call_git(
           ['clone', self.git_url, self.project_name],
           cwd=self.root_dir)
-      self._check_call_git(
-          ['svn', 'init',
+      self._check_call_git_svn(
+          ['init',
            '--prefix', self.remote + '/',
            '-T', self.trunk,
            self.svn_url])
       self._check_call_git_svn(['fetch'])
     super(GitSvnPremadeCheckout, self).prepare()
     return int(self._git_svn_info('revision'))
 
 
 class GitSvnCheckout(GitSvnCheckoutBase):
   """Manages a git-svn clone.
@@ skipping 44 matching lines @@
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path