After much refactory, finally add significant functionalities to trychanges.py

gclient_utils.py

 # Copyright 2009 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 """Generic utils."""
 
 import errno
+import logging
 import os
 import re
 import stat
 import subprocess
 import sys
 import time
 import xml.dom.minidom
 import xml.parsers.expat
 
 
 class CheckCallError(OSError):
   """CheckCall() returned non-0."""
   def __init__(self, command, cwd, retcode, stdout):
     OSError.__init__(self, command, cwd, retcode, stdout)
     self.command = command
     self.cwd = cwd
     self.retcode = retcode
     self.stdout = stdout
 
 
 def CheckCall(command, cwd=None, print_error=True):
   """Like subprocess.check_call() but returns stdout.
 
   Works on python 2.4
   """
+  logging.debug(command)

[bradn, 2009/12/23 17:30:25]

Did you want to make this more verbose? running 'blah'

   try:
     stderr = None
     if not print_error:
       stderr = subprocess.PIPE
     process = subprocess.Popen(command, cwd=cwd,
                                shell=sys.platform.startswith('win'),
                                stdout=subprocess.PIPE,
                                stderr=stderr)
     output = process.communicate()[0]
   except OSError, e:
@@ skipping 102 matching lines @@
   On POSIX systems, things are a little bit simpler.  The modes of the files
   to be deleted doesn't matter, only the modes of the directories containing
   them are significant.  As the directory tree is traversed, each directory
   has its mode set appropriately before descending into it.  This should
   result in the entire tree being removed, with the possible exception of
   *path itself, because nothing attempts to change the mode of its parent.
   Doing so would be hazardous, as it's not a directory slated for removal.
   In the ordinary case, this is not a problem: for our purposes, the user
   will never lack write permission on *path's parent.
   """
+  logging.debug(path)

[bradn, 2009/12/23 17:30:25]

Or particularly here: removing directory 'blah'

   file_path = os.path.join(*path)
   if not os.path.exists(file_path):
     return
 
   if os.path.islink(file_path) or not os.path.isdir(file_path):
     raise Error("RemoveDirectory asked to remove non-directory %s" % file_path)
 
   has_win32api = False
   if sys.platform == 'win32':
     has_win32api = True
@@ skipping 74 matching lines @@
 
   If a filter function is specified, it is expected to take a single
   string argument, and it will be called with each line of the
   subprocess's output. Each line has had the trailing newline character
   trimmed.
 
   If the command fails, as indicated by a nonzero exit status, gclient will
   exit with an exit status of fail_status.  If fail_status is None (the
   default), gclient will raise an Error exception.
   """
-
+  logging.debug(command)
   if print_messages:
     print("\n________ running \'%s\' in \'%s\'"
           % (' '.join(command), in_directory))
 
   # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for the
   # executable, but shell=True makes subprocess on Linux fail when it's called
   # with a list because it only tries to execute the first item in the list.
   kid = subprocess.Popen(command, bufsize=0, cwd=in_directory,
       shell=(sys.platform == 'win32'), stdout=subprocess.PIPE,
       stderr=subprocess.STDOUT)
@@ skipping 39 matching lines @@
   return False
 
 def FindGclientRoot(from_dir):
   """Tries to find the gclient root."""
   path = os.path.realpath(from_dir)
   while not os.path.exists(os.path.join(path, '.gclient')):
     next = os.path.split(path)
     if not next[1]:
       return None
     path = next[0]
+  logging.info('Found gclient root at ' + path)
   return path
 
 def PathDifference(root, subpath):
   """Returns the difference subpath minus root."""
   root = os.path.realpath(root)
   subpath = os.path.realpath(subpath)
   if not subpath.startswith(root):
     return None
   # If the root does not have a trailing \ or /, we add it so the returned
   # path starts immediately after the seperator regardless of whether it is
   # provided.
   root = os.path.join(root, '')
   return subpath[len(root):]