webkitpy: Remove contents of directory.

third_party/WebKit/Tools/Scripts/webkitpy/common/system/filesystem.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 10 matching lines @@
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 """Wrapper object for the file system / source tree."""
 
-import stat
 import codecs
 import errno
 import exceptions
 import glob
 import hashlib
+import logging
 import os
 import shutil
+import stat
 import sys
 import tempfile
 import time
 
 
+_log = logging.getLogger(__name__)
+
+
 class FileSystem(object):
     """FileSystem interface for webkitpy.
 
     Unless otherwise noted, all paths are allowed to be either absolute
     or relative.
     """
     sep = os.sep
     pardir = os.pardir
 
     def abspath(self, path):
@@ skipping 75 matching lines @@
 
     def isdir(self, path):
         return os.path.isdir(path)
 
     def join(self, *comps):
         return os.path.join(*comps)
 
     def listdir(self, path):
         return os.listdir(path)
 
-    def walk(self, top):
-        return os.walk(top)
+    def walk(self, top, topdown=True, onerror=None, followlinks=False):
+        return os.walk(top, topdown=topdown, onerror=onerror, followlinks=followlinks)
 
     def mkdtemp(self, **kwargs):
         """Create and return a uniquely named directory.
 
         This is like tempfile.mkdtemp, but if used in a with statement
         the directory will self-delete at the end of the block (if the
         directory is empty; non-empty directories raise errors). The
         directory can be safely deleted inside the block as well, if so
         desired.
 
@@ skipping 88 matching lines @@
     def sha1(self, path):
         contents = self.read_binary_file(path)
         return hashlib.sha1(contents).hexdigest()
 
     def relpath(self, path, start='.'):
         return os.path.relpath(path, start)
 
     class _WindowsError(exceptions.OSError):
         """Fake exception for Linux and Mac."""
 
-    def remove(self, path, osremove=os.remove):
+    def remove(self, path, osremove=os.remove, retry=True):
         """On Windows, if a process was recently killed and it held on to a
         file, the OS will hold on to the file for a short while.  This makes
         attempts to delete the file fail.  To work around that, this method
         will retry for a few seconds until Windows is done with the file.
         """
         try:
             exceptions.WindowsError
         except AttributeError:
             exceptions.WindowsError = FileSystem._WindowsError
 
         retry_timeout_sec = 3.0
         sleep_interval = 0.1
         while True:
             try:
                 osremove(path)
                 return True
             except exceptions.WindowsError:
                 time.sleep(sleep_interval)
                 retry_timeout_sec -= sleep_interval
-                if retry_timeout_sec < 0:
+                if retry_timeout_sec < 0 and not retry:
                     raise
 
-    def rmtree(self, path):
+    def rmtree(self, path, ignore_errors=True, onerror=None):
         """Delete the directory rooted at path, whether empty or not."""
-        shutil.rmtree(path, ignore_errors=True)
+        shutil.rmtree(path, ignore_errors=ignore_errors, onerror=onerror)
+
+    def remove_contents(self, dirname):
+        """Attempt to remove the contents of a directory tree.
+        Args:
+            dirname (string): Directory to remove the contents of.
+
+        Returns:
+            bool: True if the directory is now empty.
+        """
+        return _remove_contents(self, dirname)
 
     def copytree(self, source, destination):
         shutil.copytree(source, destination)
 
     def split(self, path):
         """Return (dirname, basename + '.' + ext)"""
         return os.path.split(path)
 
     def splitext(self, path):
         """Return (dirname + os.sep + basename, '.' + ext)"""
         return os.path.splitext(path)
 
     def make_executable(self, file_path):
         os.chmod(file_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IXGRP)
+
+
+# _remove_contents is implemented in terms of other FileSystem functions. To
+# allow it to be reused on the MockFileSystem object, we define it here and
+# then call it in both FileSystem and MockFileSystem classes.
+def _remove_contents(fs, dirname, sleep=time.sleep):
+    # We try multiple times, because on Windows a process which is
+    # currently closing could still have a file open in the directory.
+    _log.info('Removing contents of %s', dirname)
+    errors = []
+
+    def onerror(func, path, exc_info):
+        errors.append(path)
+        _log.exception('Failed at %s %s: %r', func, path, exc_info)
+
+    attempts = 0
+    while attempts < 5:
+        del errors[:]
+
+        for name in fs.listdir(dirname):
+            fullname = fs.join(dirname, name)
+
+            isdir = True
+            try:
+                isdir = fs.isdir(fullname)
+            except os.error:
+                onerror(fs.isdir, fullname, sys.exc_info())
+                continue
+
+            if isdir:
+                try:
+                    _log.debug('Removing directory %s', fullname)
+                    fs.rmtree(fullname, ignore_errors=False, onerror=onerror)
+                except os.error:
+                    onerror(fs.rmtree, fullname, sys.exc_info())
+                    continue
+            else:
+                try:
+                    _log.debug('Removing file %s', fullname)
+                    fs.remove(fullname, retry=False)
+                except os.error:
+                    onerror(fs.remove, fullname, sys.exc_info())
+                    continue
+
+        if not errors:
+            break
+
+        _log.warning('Contents removal failed, retrying in 1 second.')
+        attempts += 1
+        sleep(1)
+
+    # Check the path is gone.
+    if not fs.listdir(dirname):
+        return True
+
+    _log.warning('Unable to remove %s', dirname)
+    for dirpath, dirnames, filenames in fs.walk(dirname, onerror=onerror, topdown=False):
+        for fname in filenames:
+            _log.warning('File %s still in output dir.', fs.join(dirpath, fname))
+        for dname in dirnames:
+            _log.warning('Dir %s still in output dir.', fs.join(dirpath, dname))
+
+    return False