Make many operations quieter.

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 64 matching lines @@
     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(self._add_svn_flags(args), **kwargs)
 
-  def _capture_svn(self, args, **kwargs):
+  def _check_capture_svn(self, args, **kwargs):
     """Runs svn and throws an exception if the command failed.
 
      Returns the output.
     """
     kwargs.setdefault('cwd', self.project_path)
     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.
@@ skipping 60 matching lines @@
 
   def commit(self, commit_message, user):
     """Commits a patch."""
     logging.info('Committing patch for %s' % user)
     assert self.commit_user
     assert self.commit_pwd
     handle, commit_filename = tempfile.mkstemp(text=True)
     os.write(handle, commit_message)
     os.close(handle)
     try:
-      output = self._capture_svn(['commit', '--file', commit_filename])
+      output = self._check_capture_svn(['commit', '--file', commit_filename])
       revision = re.compile(
           r'.*?\nCommitted revision (\d+)',
           re.DOTALL).match(output).group(1)
       # Fix the committer.
       self._update_committer(revision, user)
     finally:
       os.remove(commit_filename)
     return int(revision)
 
   def _revert(self):
@@ skipping 35 matching lines @@
             gclient_utils.RemoveDirectory(file_path)
           else:
             logging.error('no idea what is %s.\nYou just found a bug in gclient'
                           ', please ping maruel@chromium.org ASAP!' % file_path)
         except EnvironmentError:
           logging.error('Failed to remove %s.' % file_path)
 
       # Revive files that were deleted above.
       self._check_call_svn(['update', '--force'] + flags)
 
-    out = self._capture_svn(['info', '.'])
+    out = self._check_capture_svn(['info', '.'])
     return int(self._parse_svn_info(out, 'revision'))
 
 
 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])
+    branches, active = self._branches()
+    if active != 'master':
+      self._check_call_git(['checkout', 'master', '--force', '--quiet'])
+    self._check_call_git(['pull', self.remote, self.remote_branch, '--quiet'])
+    if self.working_branch in branches:
+      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)
 
   def _check_capture_git(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.check_capture(['git'] + args, **kwargs)
 
+  def _branches(self):
+    """Returns the list of branches and the active one."""
+    out = self._check_capture_git(['branch']).splitlines(False)
+    branches = [l[2:] for l in out]
+    active = None
+    for l in out:
+      if l.startswith('*'):
+        active = l[2:]
+        break
+    return branches, active
+
 
 class GitSvnCheckoutBase(GitCheckoutBase, SvnMixIn):
   """Base class for git-svn checkout. Not to be used as-is."""
   def __init__(self,
       root_dir, project_name, remote_branch,
       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._call_git(['branch', '-D', self.working_branch])
+    branches, active = self._branches()
+    if active != 'master':
+      self._check_call_git(['checkout', 'master', '--force', '--quiet'])
+    # git svn rebase --quiet --quiet doesn't work, use two steps to silence it.
+    self._check_call_git_svn(['fetch'])
+    self._check_call_git(
+        ['rebase', '--quiet', '%s/%s' % (self.remote, self.remote_branch)])
+    if self.working_branch in branches:
+      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)
-    self._check_call_svn(['ls', self.svn_url], cwd=None)
+    # Use capture to lower noise in logs.
+    self._check_capture_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 + ['--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.
@@ skipping 80 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