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

   1 # Copyright (C) 2010 Google Inc. All rights reserved.
   2 #
   3 # Redistribution and use in source and binary forms, with or without
   4 # modification, are permitted provided that the following conditions are
   5 # met:
   6 #
   7 #     * Redistributions of source code must retain the above copyright
   8 # notice, this list of conditions and the following disclaimer.
   9 #     * Redistributions in binary form must reproduce the above
  10 # copyright notice, this list of conditions and the following disclaimer
  11 # in the documentation and/or other materials provided with the
  12 # distribution.
  13 #     * Neither the name of Google Inc. nor the names of its
  14 # contributors may be used to endorse or promote products derived from
  15 # this software without specific prior written permission.
  16 #
  17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 """Wrapper object for the file system / source tree."""
  30
  31 from __future__ import with_statement
  32
  33 import codecs
  34 import errno
  35 import exceptions
  36 import glob
  37 import os
  38 import shutil
  39 import tempfile
  40 import time
  41
  42 class FileSystem(object):
  43     """FileSystem interface for webkitpy.
  44
  45     Unless otherwise noted, all paths are allowed to be either absolute
  46     or relative."""
  47     def __init__(self):
  48         self.sep = os.sep
  49
  50     def abspath(self, path):
  51         return os.path.abspath(path)
  52
  53     def basename(self, path):
  54         """Wraps os.path.basename()."""
  55         return os.path.basename(path)
  56
  57     def copyfile(self, source, destination):
  58         """Copies the contents of the file at the given path to the destination
  59         path."""
  60         shutil.copyfile(source, destination)
  61
  62     def dirname(self, path):
  63         """Wraps os.path.dirname()."""
  64         return os.path.dirname(path)
  65
  66     def exists(self, path):
  67         """Return whether the path exists in the filesystem."""
  68         return os.path.exists(path)
  69
  70     def files_under(self, path, dirs_to_skip=[], file_filter=None):
  71         """Return the list of all files under the given path in topdown order.
  72
  73         Args:
  74             dirs_to_skip: a list of directories to skip over during the
  75                 traversal (e.g., .svn, resources, etc.)
  76             file_filter: if not None, the filter will be invoked
  77                 with the filesystem object and the dirname and basename of
  78                 each file found. The file is included in the result if the
  79                 callback returns True.
  80         """
  81         def filter_all(fs, dirpath, basename):
  82             return True
  83
  84         file_filter = file_filter or filter_all
  85         files = []
  86         if self.isfile(path):
  87             if file_filter(self, self.dirname(path), self.basename(path)):
  88                 files.append(path)
  89             return files
  90
  91         if self.basename(path) in dirs_to_skip:
  92             return []
  93
  94         for (dirpath, dirnames, filenames) in os.walk(path):
  95             for d in dirs_to_skip:
  96                 if d in dirnames:
  97                     dirnames.remove(d)
  98
  99             for filename in filenames:
 100                 if file_filter(self, dirpath, filename):
 101                     files.append(self.join(dirpath, filename))
 102         return files
 103
 104     def glob(self, path):
 105         """Wraps glob.glob()."""
 106         return glob.glob(path)
 107
 108     def isabs(self, path):
 109         """Return whether the path is an absolute path."""
 110         return os.path.isabs(path)
 111
 112     def isfile(self, path):
 113         """Return whether the path refers to a file."""
 114         return os.path.isfile(path)
 115
 116     def isdir(self, path):
 117         """Return whether the path refers to a directory."""
 118         return os.path.isdir(path)
 119
 120     def join(self, *comps):
 121         """Return the path formed by joining the components."""
 122         return os.path.join(*comps)
 123
 124     def listdir(self, path):
 125         """Return the contents of the directory pointed to by path."""
 126         return os.listdir(path)
 127
 128     def mkdtemp(self, **kwargs):
 129         """Create and return a uniquely named directory.
 130
 131         This is like tempfile.mkdtemp, but if used in a with statement
 132         the directory will self-delete at the end of the block (if the
 133         directory is empty; non-empty directories raise errors). The
 134         directory can be safely deleted inside the block as well, if so
 135         desired.
 136
 137         Note that the object returned is not a string and does not support all of the string
 138         methods. If you need a string, coerce the object to a string and go from there.
 139         """
 140         class TemporaryDirectory(object):
 141             def __init__(self, **kwargs):
 142                 self._kwargs = kwargs
 143                 self._directory_path = tempfile.mkdtemp(**self._kwargs)
 144
 145             def __str__(self):
 146                 return self._directory_path
 147
 148             def __enter__(self):
 149                 return self._directory_path
 150
 151             def __exit__(self, type, value, traceback):
 152                 # Only self-delete if necessary.
 153
 154                 # FIXME: Should we delete non-empty directories?
 155                 if os.path.exists(self._directory_path):
 156                     os.rmdir(self._directory_path)
 157
 158         return TemporaryDirectory(**kwargs)
 159
 160     def maybe_make_directory(self, *path):
 161         """Create the specified directory if it doesn't already exist."""
 162         try:
 163             os.makedirs(self.join(*path))
 164         except OSError, e:
 165             if e.errno != errno.EEXIST:
 166                 raise
 167
 168     def move(self, src, dest):
 169         shutil.move(src, dest)
 170
 171     def mtime(self, path):
 172         return os.stat(path).st_mtime
 173
 174     def normpath(self, path):
 175         """Wraps os.path.normpath()."""
 176         return os.path.normpath(path)
 177
 178     def open_binary_tempfile(self, suffix):
 179         """Create, open, and return a binary temp file. Returns a tuple of the file and the name."""
 180         temp_fd, temp_name = tempfile.mkstemp(suffix)
 181         f = os.fdopen(temp_fd, 'wb')
 182         return f, temp_name
 183
 184     def open_text_file_for_writing(self, path, append=False):
 185         """Returns a file handle suitable for writing to."""
 186         mode = 'w'
 187         if append:
 188             mode = 'wa'
 189         return codecs.open(path, mode, 'utf8')
 190
 191     def read_binary_file(self, path):
 192         """Return the contents of the file at the given path as a byte string."""
 193         with file(path, 'rb') as f:
 194             return f.read()
 195
 196     def read_text_file(self, path):
 197         """Return the contents of the file at the given path as a Unicode string.
 198
 199         The file is read assuming it is a UTF-8 encoded file with no BOM."""
 200         with codecs.open(path, 'r', 'utf8') as f:
 201             return f.read()
 202
 203     class _WindowsError(exceptions.OSError):
 204         """Fake exception for Linux and Mac."""
 205         pass
 206
 207     def remove(self, path, osremove=os.remove):
 208         """On Windows, if a process was recently killed and it held on to a
 209         file, the OS will hold on to the file for a short while.  This makes
 210         attempts to delete the file fail.  To work around that, this method
 211         will retry for a few seconds until Windows is done with the file."""
 212         try:
 213             exceptions.WindowsError
 214         except AttributeError:
 215             exceptions.WindowsError = FileSystem._WindowsError
 216
 217         retry_timeout_sec = 3.0
 218         sleep_interval = 0.1
 219         while True:
 220             try:
 221                 osremove(path)
 222                 return True
 223             except exceptions.WindowsError, e:
 224                 time.sleep(sleep_interval)
 225                 retry_timeout_sec -= sleep_interval
 226                 if retry_timeout_sec < 0:
 227                     raise e
 228
 229     def rmtree(self, path):
 230         """Delete the directory rooted at path, empty or no."""
 231         shutil.rmtree(path, ignore_errors=True)
 232
 233     def read_binary_file(self, path):
 234         """Return the contents of the file at the given path as a byte string."""
 235         with file(path, 'rb') as f:
 236             return f.read()
 237
 238     def read_text_file(self, path):
 239         """Return the contents of the file at the given path as a Unicode string.
 240
 241         The file is read assuming it is a UTF-8 encoded file with no BOM."""
 242         with codecs.open(path, 'r', 'utf8') as f:
 243             return f.read()
 244
 245     def splitext(self, path):
 246         """Return (dirname + os.sep + basename, '.' + ext)"""
 247         return os.path.splitext(path)
 248
 249     def write_binary_file(self, path, contents):
 250         """Write the contents to the file at the given location."""
 251         with file(path, 'wb') as f:
 252             f.write(contents)
 253
 254     def write_text_file(self, path, contents):
 255         """Write the contents to the file at the given location.
 256
 257         The file is written encoded as UTF-8 with no BOM."""
 258         with codecs.open(path, 'w', 'utf8') as f:
 259             f.write(contents)