Shorten RemoveDirectory and rename to rmtree. Remove rmtree from fake_repos.

gclient_utils.py

 # 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.
 
 """Generic utils."""
 
 import errno
 import logging
 import os
 import Queue
@@ skipping 164 matching lines @@
 
 
 def FileWrite(filename, content, mode='w'):
   f = open(filename, mode)
   try:
     f.write(content)
   finally:
     f.close()
 
 
-def RemoveDirectory(*path):
-  """Recursively removes a directory, even if it's marked read-only.
+def rmtree(path):
+  """shutil.rmtree() on steroids.
 
-  Remove the directory located at *path, if it exists.
+  Recursively removes a directory, even if it's marked read-only.
 
   shutil.rmtree() doesn't work on Windows if any of the files or directories
   are read-only, which svn repositories and some .svn files are.  We need to
   be able to force the files to be writable (i.e., deletable) as we traverse
   the tree.
 
   Even with all this, Windows still sometimes fails to delete a file, citing
   a permission error (maybe something to do with antivirus scans or disk
   indexing).  The best suggestion any of the user forums had was to wait a
   bit and try again, so we do that too.  It's hand-waving, but sometimes it
   works. :/
 
   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)
-  file_path = os.path.join(*path)
-  if not os.path.exists(file_path):
+  if not os.path.exists(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)
+  if os.path.islink(path) or not os.path.isdir(path):
+    raise Error('Called rmtree(%s) in non-directory' % path)
 
-  has_win32api = False
   if sys.platform == 'win32':
-    has_win32api = True
     # Some people don't have the APIs installed. In that case we'll do without.
     try:
       win32api = __import__('win32api')
       win32con = __import__('win32con')
     except ImportError:
-      has_win32api = False
+      pass
   else:
     # On POSIX systems, we need the x-bit set on the directory to access it,
     # the r-bit to see its contents, and the w-bit to remove files from it.
     # The actual modes of the files within the directory is irrelevant.
-    os.chmod(file_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
-  for fn in os.listdir(file_path):
-    fullpath = os.path.join(file_path, fn)
+    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
 
+  def remove(func, subpath):
+    if sys.platform == 'win32':
+      os.chmod(subpath, stat.S_IWRITE)
+      if win32api and win32con:
+        win32api.SetFileAttributes(subpath, win32con.FILE_ATTRIBUTE_NORMAL)
+    try:
+      func(subpath)
+    except OSError, e:
+      if e.errno != errno.EACCES or sys.platform != 'win32':
+        raise
+      # Failed to delete, try again after a 100ms sleep.
+      time.sleep(0.1)
+      func(subpath)
+
+  for fn in os.listdir(path):
     # If fullpath is a symbolic link that points to a directory, isdir will
     # be True, but we don't want to descend into that as a directory, we just
     # want to remove the link.  Check islink and treat links as ordinary files
     # would be treated regardless of what they reference.
+    fullpath = os.path.join(path, fn)
     if os.path.islink(fullpath) or not os.path.isdir(fullpath):
-      if sys.platform == 'win32':
-        os.chmod(fullpath, stat.S_IWRITE)
-        if has_win32api:
-          win32api.SetFileAttributes(fullpath, win32con.FILE_ATTRIBUTE_NORMAL)
-      try:
-        os.remove(fullpath)
-      except OSError, e:
-        if e.errno != errno.EACCES or sys.platform != 'win32':
-          raise
-        print 'Failed to delete %s: trying again' % fullpath
-        time.sleep(0.1)
-        os.remove(fullpath)
+      remove(os.remove, fullpath)
     else:
-      RemoveDirectory(fullpath)
+      # Recurse.
+      rmtree(fullpath)
 
-  if sys.platform == 'win32':
-    os.chmod(file_path, stat.S_IWRITE)
-    if has_win32api:
-      win32api.SetFileAttributes(file_path, win32con.FILE_ATTRIBUTE_NORMAL)
-  try:
-    os.rmdir(file_path)
-  except OSError, e:
-    if e.errno != errno.EACCES or sys.platform != 'win32':
-      raise
-    print 'Failed to remove %s: trying again' % file_path
-    time.sleep(0.1)
-    os.rmdir(file_path)
+  remove(os.rmdir, path)
+
+# TODO(maruel): Rename the references.
+RemoveDirectory = rmtree
 
 
 def CheckCallAndFilterAndHeader(args, always=False, **kwargs):
   """Adds 'header' support to CheckCallAndFilter.
 
   If |always| is True, a message indicating what is being done
   is printed to stdout all the time even if not output is generated. Otherwise
   the message header is printed only if the call generated any ouput.
   """
   stdout = kwargs.get('stdout', None) or sys.stdout
@@ skipping 430 matching lines @@
         logging.info('Caught exception in thread %s' % self.item.name)
         logging.info(str(sys.exc_info()))
         work_queue.exceptions.put(sys.exc_info())
       logging.info('Task %s done' % self.item.name)
 
       work_queue.ready_cond.acquire()
       try:
         work_queue.ready_cond.notifyAll()
       finally:
         work_queue.ready_cond.release()