src/allmydata/util/fileutil.py

   1 """
   2 Futz with files like a pro.
   3 """
   4
   5 import sys, exceptions, os, stat, tempfile, time, binascii
   6 from collections import namedtuple
   7 from errno import ENOENT
   8
   9 if sys.platform == "win32":
  10     from ctypes import WINFUNCTYPE, WinError, windll, POINTER, byref, c_ulonglong, \
  11         create_unicode_buffer, get_last_error
  12     from ctypes.wintypes import BOOL, HANDLE, DWORD, LPCWSTR, LPWSTR, LPVOID
  13
  14 from twisted.python import log
  15
  16 from pycryptopp.cipher.aes import AES
  17
  18
  19 def rename(src, dst, tries=4, basedelay=0.1):
  20     """ Here is a superkludge to workaround the fact that occasionally on
  21     Windows some other process (e.g. an anti-virus scanner, a local search
  22     engine, etc.) is looking at your file when you want to delete or move it,
  23     and hence you can't.  The horrible workaround is to sit and spin, trying
  24     to delete it, for a short time and then give up.
  25
  26     With the default values of tries and basedelay this can block for less
  27     than a second.
  28
  29     @param tries: number of tries -- each time after the first we wait twice
  30     as long as the previous wait
  31     @param basedelay: how long to wait before the second try
  32     """
  33     for i in range(tries-1):
  34         try:
  35             return os.rename(src, dst)
  36         except EnvironmentError, le:
  37             # XXX Tighten this to check if this is a permission denied error (possibly due to another Windows process having the file open and execute the superkludge only in this case.
  38             log.msg("XXX KLUDGE Attempting to move file %s => %s; got %s; sleeping %s seconds" % (src, dst, le, basedelay,))
  39             time.sleep(basedelay)
  40             basedelay *= 2
  41     return os.rename(src, dst) # The last try.
  42
  43 def remove(f, tries=4, basedelay=0.1):
  44     """ Here is a superkludge to workaround the fact that occasionally on
  45     Windows some other process (e.g. an anti-virus scanner, a local search
  46     engine, etc.) is looking at your file when you want to delete or move it,
  47     and hence you can't.  The horrible workaround is to sit and spin, trying
  48     to delete it, for a short time and then give up.
  49
  50     With the default values of tries and basedelay this can block for less
  51     than a second.
  52
  53     @param tries: number of tries -- each time after the first we wait twice
  54     as long as the previous wait
  55     @param basedelay: how long to wait before the second try
  56     """
  57     try:
  58         os.chmod(f, stat.S_IWRITE | stat.S_IEXEC | stat.S_IREAD)
  59     except:
  60         pass
  61     for i in range(tries-1):
  62         try:
  63             return os.remove(f)
  64         except EnvironmentError, le:
  65             # XXX Tighten this to check if this is a permission denied error (possibly due to another Windows process having the file open and execute the superkludge only in this case.
  66             if not os.path.exists(f):
  67                 return
  68             log.msg("XXX KLUDGE Attempting to remove file %s; got %s; sleeping %s seconds" % (f, le, basedelay,))
  69             time.sleep(basedelay)
  70             basedelay *= 2
  71     return os.remove(f) # The last try.
  72
  73 class ReopenableNamedTemporaryFile:
  74     """
  75     This uses tempfile.mkstemp() to generate a secure temp file.  It then closes
  76     the file, leaving a zero-length file as a placeholder.  You can get the
  77     filename with ReopenableNamedTemporaryFile.name.  When the
  78     ReopenableNamedTemporaryFile instance is garbage collected or its shutdown()
  79     method is called, it deletes the file.
  80     """
  81     def __init__(self, *args, **kwargs):
  82         fd, self.name = tempfile.mkstemp(*args, **kwargs)
  83         os.close(fd)
  84
  85     def __repr__(self):
  86         return "<%s instance at %x %s>" % (self.__class__.__name__, id(self), self.name)
  87
  88     def __str__(self):
  89         return self.__repr__()
  90
  91     def __del__(self):
  92         self.shutdown()
  93
  94     def shutdown(self):
  95         remove(self.name)
  96
  97 class EncryptedTemporaryFile:
  98     # not implemented: next, readline, readlines, xreadlines, writelines
  99
 100     def __init__(self):
 101         self.file = tempfile.TemporaryFile()
 102         self.key = os.urandom(16)  # AES-128
 103
 104     def _crypt(self, offset, data):
 105         offset_big = offset // 16
 106         offset_small = offset % 16
 107         iv = binascii.unhexlify("%032x" % offset_big)
 108         cipher = AES(self.key, iv=iv)
 109         cipher.process("\x00"*offset_small)
 110         return cipher.process(data)
 111
 112     def close(self):
 113         self.file.close()
 114
 115     def flush(self):
 116         self.file.flush()
 117
 118     def seek(self, offset, whence=0):  # 0 = SEEK_SET
 119         self.file.seek(offset, whence)
 120
 121     def tell(self):
 122         offset = self.file.tell()
 123         return offset
 124
 125     def read(self, size=-1):
 126         """A read must not follow a write, or vice-versa, without an intervening seek."""
 127         index = self.file.tell()
 128         ciphertext = self.file.read(size)
 129         plaintext = self._crypt(index, ciphertext)
 130         return plaintext
 131
 132     def write(self, plaintext):
 133         """A read must not follow a write, or vice-versa, without an intervening seek.
 134         If seeking and then writing causes a 'hole' in the file, the contents of the
 135         hole are unspecified."""
 136         index = self.file.tell()
 137         ciphertext = self._crypt(index, plaintext)
 138         self.file.write(ciphertext)
 139
 140     def truncate(self, newsize):
 141         """Truncate or extend the file to 'newsize'. If it is extended, the contents after the
 142         old end-of-file are unspecified. The file position after this operation is unspecified."""
 143         self.file.truncate(newsize)
 144
 145
 146 def make_dirs(dirname, mode=0777):
 147     """
 148     An idempotent version of os.makedirs().  If the dir already exists, do
 149     nothing and return without raising an exception.  If this call creates the
 150     dir, return without raising an exception.  If there is an error that
 151     prevents creation or if the directory gets deleted after make_dirs() creates
 152     it and before make_dirs() checks that it exists, raise an exception.
 153     """
 154     tx = None
 155     try:
 156         os.makedirs(dirname, mode)
 157     except OSError, x:
 158         tx = x
 159
 160     if not os.path.isdir(dirname):
 161         if tx:
 162             raise tx
 163         raise exceptions.IOError, "unknown error prevented creation of directory, or deleted the directory immediately after creation: %s" % dirname # careful not to construct an IOError with a 2-tuple, as that has a special meaning...
 164
 165 def rm_dir(dirname):
 166     """
 167     A threadsafe and idempotent version of shutil.rmtree().  If the dir is
 168     already gone, do nothing and return without raising an exception.  If this
 169     call removes the dir, return without raising an exception.  If there is an
 170     error that prevents deletion or if the directory gets created again after
 171     rm_dir() deletes it and before rm_dir() checks that it is gone, raise an
 172     exception.
 173     """
 174     excs = []
 175     try:
 176         os.chmod(dirname, stat.S_IWRITE | stat.S_IEXEC | stat.S_IREAD)
 177         for f in os.listdir(dirname):
 178             fullname = os.path.join(dirname, f)
 179             if os.path.isdir(fullname):
 180                 rm_dir(fullname)
 181             else:
 182                 remove(fullname)
 183         os.rmdir(dirname)
 184     except Exception, le:
 185         # Ignore "No such file or directory"
 186         if (not isinstance(le, OSError)) or le.args[0] != 2:
 187             excs.append(le)
 188
 189     # Okay, now we've recursively removed everything, ignoring any "No
 190     # such file or directory" errors, and collecting any other errors.
 191
 192     if os.path.exists(dirname):
 193         if len(excs) == 1:
 194             raise excs[0]
 195         if len(excs) == 0:
 196             raise OSError, "Failed to remove dir for unknown reason."
 197         raise OSError, excs
 198
 199
 200 def remove_if_possible(f):
 201     try:
 202         remove(f)
 203     except:
 204         pass
 205
 206 def du(basedir):
 207     size = 0
 208
 209     for root, dirs, files in os.walk(basedir):
 210         for f in files:
 211             fn = os.path.join(root, f)
 212             size += os.path.getsize(fn)
 213
 214     return size
 215
 216 def move_into_place(source, dest):
 217     """Atomically replace a file, or as near to it as the platform allows.
 218     The dest file may or may not exist."""
 219     if "win32" in sys.platform.lower():
 220         remove_if_possible(dest)
 221     os.rename(source, dest)
 222
 223 def write_atomically(target, contents, mode="b"):
 224     f = open(target+".tmp", "w"+mode)
 225     try:
 226         f.write(contents)
 227     finally:
 228         f.close()
 229     move_into_place(target+".tmp", target)
 230
 231 def write(path, data, mode="wb"):
 232     wf = open(path, mode)
 233     try:
 234         wf.write(data)
 235     finally:
 236         wf.close()
 237
 238 def read(path):
 239     rf = open(path, "rb")
 240     try:
 241         return rf.read()
 242     finally:
 243         rf.close()
 244
 245 def put_file(path, inf):
 246     precondition_abspath(path)
 247
 248     # TODO: create temporary file and move into place?
 249     outf = open(path, "wb")
 250     try:
 251         while True:
 252             data = inf.read(32768)
 253             if not data:
 254                 break
 255             outf.write(data)
 256     finally:
 257         outf.close()
 258
 259
 260 def precondition_abspath(path):
 261     if not isinstance(path, unicode):
 262         raise AssertionError("an abspath must be a Unicode string")
 263
 264     if sys.platform == "win32":
 265         # This intentionally doesn't view absolute paths starting with a drive specification, or
 266         # paths relative to the current drive, as acceptable.
 267         if not path.startswith("\\\\"):
 268             raise AssertionError("an abspath should be normalized using abspath_expanduser_unicode")
 269     else:
 270         # This intentionally doesn't view the path '~' or paths starting with '~/' as acceptable.
 271         if not os.path.isabs(path):
 272             raise AssertionError("an abspath should be normalized using abspath_expanduser_unicode")
 273
 274 # Work around <http://bugs.python.org/issue3426>. This code is adapted from
 275 # <http://svn.python.org/view/python/trunk/Lib/ntpath.py?revision=78247&view=markup>
 276 # with some simplifications.
 277
 278 _getfullpathname = None
 279 try:
 280     from nt import _getfullpathname
 281 except ImportError:
 282     pass
 283
 284 def abspath_expanduser_unicode(path, base=None, long_path=True):
 285     """
 286     Return the absolute version of a path. If 'base' is given and 'path' is relative,
 287     the path will be expanded relative to 'base'.
 288     'path' must be a Unicode string. 'base', if given, must be a Unicode string
 289     corresponding to an absolute path as returned by a previous call to
 290     abspath_expanduser_unicode.
 291     On Windows, the result will be a long path unless long_path is given as False.
 292     """
 293     if not isinstance(path, unicode):
 294         raise AssertionError("paths must be Unicode strings")
 295     if base is not None and long_path:
 296         precondition_abspath(base)
 297
 298     path = expanduser(path)
 299
 300     if _getfullpathname:
 301         # On Windows, os.path.isabs will incorrectly return True
 302         # for paths without a drive letter (that are not UNC paths),
 303         # e.g. "\\". See <http://bugs.python.org/issue1669539>.
 304         try:
 305             if base is None:
 306                 path = _getfullpathname(path or u".")
 307             else:
 308                 path = _getfullpathname(os.path.join(base, path))
 309         except OSError:
 310             pass
 311
 312     if not os.path.isabs(path):
 313         if base is None:
 314             path = os.path.join(os.getcwdu(), path)
 315         else:
 316             path = os.path.join(base, path)
 317
 318     # We won't hit <http://bugs.python.org/issue5827> because
 319     # there is always at least one Unicode path component.
 320     path = os.path.normpath(path)
 321
 322     if sys.platform == "win32" and long_path:
 323         path = to_windows_long_path(path)
 324
 325     return path
 326
 327 def to_windows_long_path(path):
 328     # '/' is normally a perfectly valid path component separator in Windows.
 329     # However, when using the "\\?\" syntax it is not recognized, so we
 330     # replace it with '\' here.
 331     path = path.replace(u"/", u"\\")
 332
 333     # Note that other normalizations such as removing '.' and '..' should
 334     # be done outside this function.
 335
 336     if path.startswith(u"\\\\?\\") or path.startswith(u"\\\\.\\"):
 337         return path
 338     elif path.startswith(u"\\\\"):
 339         return u"\\\\?\\UNC\\" + path[2 :]
 340     else:
 341         return u"\\\\?\\" + path
 342
 343
 344 have_GetDiskFreeSpaceExW = False
 345 if sys.platform == "win32":
 346     # <http://msdn.microsoft.com/en-us/library/windows/desktop/ms683188%28v=vs.85%29.aspx>
 347     GetEnvironmentVariableW = WINFUNCTYPE(
 348         DWORD,  LPCWSTR, LPWSTR, DWORD,
 349         use_last_error=True
 350     )(("GetEnvironmentVariableW", windll.kernel32))
 351
 352     try:
 353         # <http://msdn.microsoft.com/en-us/library/aa383742%28v=VS.85%29.aspx>
 354         PULARGE_INTEGER = POINTER(c_ulonglong)
 355
 356         # <http://msdn.microsoft.com/en-us/library/aa364937%28VS.85%29.aspx>
 357         GetDiskFreeSpaceExW = WINFUNCTYPE(
 358             BOOL,  LPCWSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER,
 359             use_last_error=True
 360         )(("GetDiskFreeSpaceExW", windll.kernel32))
 361
 362         have_GetDiskFreeSpaceExW = True
 363     except Exception:
 364         import traceback
 365         traceback.print_exc()
 366
 367 def expanduser(path):
 368     # os.path.expanduser is hopelessly broken for Unicode paths on Windows (ticket #1674).
 369     if sys.platform == "win32":
 370         return windows_expanduser(path)
 371     else:
 372         return os.path.expanduser(path)
 373
 374 def windows_expanduser(path):
 375     if not path.startswith('~'):
 376         return path
 377
 378     home_dir = windows_getenv(u'USERPROFILE')
 379     if home_dir is None:
 380         home_drive = windows_getenv(u'HOMEDRIVE')
 381         home_path = windows_getenv(u'HOMEPATH')
 382         if home_drive is None or home_path is None:
 383             raise OSError("Could not find home directory: neither %USERPROFILE% nor (%HOMEDRIVE% and %HOMEPATH%) are set.")
 384         home_dir = os.path.join(home_drive, home_path)
 385
 386     if path == '~':
 387         return home_dir
 388     elif path.startswith('~/') or path.startswith('~\\'):
 389         return os.path.join(home_dir, path[2 :])
 390     else:
 391         return path
 392
 393 # <https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382%28v=vs.85%29.aspx>
 394 ERROR_ENVVAR_NOT_FOUND = 203
 395
 396 def windows_getenv(name):
 397     # Based on <http://stackoverflow.com/questions/2608200/problems-with-umlauts-in-python-appdata-environvent-variable/2608368#2608368>,
 398     # with improved error handling. Returns None if there is no enivronment variable of the given name.
 399     if not isinstance(name, unicode):
 400         raise AssertionError("name must be Unicode")
 401
 402     n = GetEnvironmentVariableW(name, None, 0)
 403     # GetEnvironmentVariableW returns DWORD, so n cannot be negative.
 404     if n == 0:
 405         err = get_last_error()
 406         if err == ERROR_ENVVAR_NOT_FOUND:
 407             return None
 408         raise OSError("WinError: %s\n attempting to read size of environment variable %r"
 409                       % (WinError(err), name))
 410     if n == 1:
 411         # Avoid an ambiguity between a zero-length string and an error in the return value of the
 412         # call to GetEnvironmentVariableW below.
 413         return u""
 414
 415     buf = create_unicode_buffer(u'\0'*n)
 416     retval = GetEnvironmentVariableW(name, buf, n)
 417     if retval == 0:
 418         err = get_last_error()
 419         if err == ERROR_ENVVAR_NOT_FOUND:
 420             return None
 421         raise OSError("WinError: %s\n attempting to read environment variable %r"
 422                       % (WinError(err), name))
 423     if retval >= n:
 424         raise OSError("Unexpected result %d (expected less than %d) from GetEnvironmentVariableW attempting to read environment variable %r"
 425                       % (retval, n, name))
 426
 427     return buf.value
 428
 429 def get_disk_stats(whichdir, reserved_space=0):
 430     """Return disk statistics for the storage disk, in the form of a dict
 431     with the following fields.
 432       total:            total bytes on disk
 433       free_for_root:    bytes actually free on disk
 434       free_for_nonroot: bytes free for "a non-privileged user" [Unix] or
 435                           the current user [Windows]; might take into
 436                           account quotas depending on platform
 437       used:             bytes used on disk
 438       avail:            bytes available excluding reserved space
 439     An AttributeError can occur if the OS has no API to get disk information.
 440     An EnvironmentError can occur if the OS call fails.
 441
 442     whichdir is a directory on the filesystem in question -- the
 443     answer is about the filesystem, not about the directory, so the
 444     directory is used only to specify which filesystem.
 445
 446     reserved_space is how many bytes to subtract from the answer, so
 447     you can pass how many bytes you would like to leave unused on this
 448     filesystem as reserved_space.
 449     """
 450
 451     if have_GetDiskFreeSpaceExW:
 452         # If this is a Windows system and GetDiskFreeSpaceExW is available, use it.
 453         # (This might put up an error dialog unless
 454         # SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX) has been called,
 455         # which we do in allmydata.windows.fixups.initialize().)
 456
 457         n_free_for_nonroot = c_ulonglong(0)
 458         n_total            = c_ulonglong(0)
 459         n_free_for_root    = c_ulonglong(0)
 460         retval = GetDiskFreeSpaceExW(whichdir, byref(n_free_for_nonroot),
 461                                                byref(n_total),
 462                                                byref(n_free_for_root))
 463         if retval == 0:
 464             raise OSError("WinError: %s\n attempting to get disk statistics for %r"
 465                           % (WinError(get_last_error()), whichdir))
 466         free_for_nonroot = n_free_for_nonroot.value
 467         total            = n_total.value
 468         free_for_root    = n_free_for_root.value
 469     else:
 470         # For Unix-like systems.
 471         # <http://docs.python.org/library/os.html#os.statvfs>
 472         # <http://opengroup.org/onlinepubs/7990989799/xsh/fstatvfs.html>
 473         # <http://opengroup.org/onlinepubs/7990989799/xsh/sysstatvfs.h.html>
 474         s = os.statvfs(whichdir)
 475
 476         # on my mac laptop:
 477         #  statvfs(2) is a wrapper around statfs(2).
 478         #    statvfs.f_frsize = statfs.f_bsize :
 479         #     "minimum unit of allocation" (statvfs)
 480         #     "fundamental file system block size" (statfs)
 481         #    statvfs.f_bsize = statfs.f_iosize = stat.st_blocks : preferred IO size
 482         # on an encrypted home directory ("FileVault"), it gets f_blocks
 483         # wrong, and s.f_blocks*s.f_frsize is twice the size of my disk,
 484         # but s.f_bavail*s.f_frsize is correct
 485
 486         total = s.f_frsize * s.f_blocks
 487         free_for_root = s.f_frsize * s.f_bfree
 488         free_for_nonroot = s.f_frsize * s.f_bavail
 489
 490     # valid for all platforms:
 491     used = total - free_for_root
 492     avail = max(free_for_nonroot - reserved_space, 0)
 493
 494     return { 'total': total,
 495              'free_for_root': free_for_root,
 496              'free_for_nonroot': free_for_nonroot,
 497              'used': used,
 498              'avail': avail,
 499            }
 500
 501 def get_available_space(whichdir, reserved_space):
 502     """Returns available space for share storage in bytes, or None if no
 503     API to get this information is available.
 504
 505     whichdir is a directory on the filesystem in question -- the
 506     answer is about the filesystem, not about the directory, so the
 507     directory is used only to specify which filesystem.
 508
 509     reserved_space is how many bytes to subtract from the answer, so
 510     you can pass how many bytes you would like to leave unused on this
 511     filesystem as reserved_space.
 512     """
 513     try:
 514         return get_disk_stats(whichdir, reserved_space)['avail']
 515     except AttributeError:
 516         return None
 517     except EnvironmentError:
 518         log.msg("OS call to get disk statistics failed")
 519         return 0
 520
 521
 522 if sys.platform == "win32":
 523     # <http://msdn.microsoft.com/en-us/library/aa363858%28v=vs.85%29.aspx>
 524     CreateFileW = WINFUNCTYPE(
 525         HANDLE,  LPCWSTR, DWORD, DWORD, LPVOID, DWORD, DWORD, HANDLE,
 526         use_last_error=True
 527     )(("CreateFileW", windll.kernel32))
 528
 529     GENERIC_WRITE        = 0x40000000
 530     FILE_SHARE_READ      = 0x00000001
 531     FILE_SHARE_WRITE     = 0x00000002
 532     OPEN_EXISTING        = 3
 533     INVALID_HANDLE_VALUE = 0xFFFFFFFF
 534
 535     # <http://msdn.microsoft.com/en-us/library/aa364439%28v=vs.85%29.aspx>
 536     FlushFileBuffers = WINFUNCTYPE(
 537         BOOL,  HANDLE,
 538         use_last_error=True
 539     )(("FlushFileBuffers", windll.kernel32))
 540
 541     # <http://msdn.microsoft.com/en-us/library/ms724211%28v=vs.85%29.aspx>
 542     CloseHandle = WINFUNCTYPE(
 543         BOOL,  HANDLE,
 544         use_last_error=True
 545     )(("CloseHandle", windll.kernel32))
 546
 547     # <http://social.msdn.microsoft.com/forums/en-US/netfxbcl/thread/4465cafb-f4ed-434f-89d8-c85ced6ffaa8/>
 548     def flush_volume(path):
 549         drive = os.path.splitdrive(os.path.realpath(path))[0]
 550
 551         hVolume = CreateFileW(u"\\\\.\\" + drive,
 552                               GENERIC_WRITE,
 553                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 554                               None,
 555                               OPEN_EXISTING,
 556                               0,
 557                               None
 558                              )
 559         if hVolume == INVALID_HANDLE_VALUE:
 560             raise WinError(get_last_error())
 561
 562         if FlushFileBuffers(hVolume) == 0:
 563             raise WinError(get_last_error())
 564
 565         CloseHandle(hVolume)
 566 else:
 567     def flush_volume(path):
 568         # use sync()?
 569         pass
 570
 571
 572 class ConflictError(Exception):
 573     pass
 574
 575 class UnableToUnlinkReplacementError(Exception):
 576     pass
 577
 578 def reraise(wrapper):
 579     _, exc, tb = sys.exc_info()
 580     wrapper_exc = wrapper("%s: %s" % (exc.__class__.__name__, exc))
 581     raise wrapper_exc.__class__, wrapper_exc, tb
 582
 583 if sys.platform == "win32":
 584     # <https://msdn.microsoft.com/en-us/library/windows/desktop/aa365512%28v=vs.85%29.aspx>
 585     ReplaceFileW = WINFUNCTYPE(
 586         BOOL,  LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID,
 587         use_last_error=True
 588     )(("ReplaceFileW", windll.kernel32))
 589
 590     REPLACEFILE_IGNORE_MERGE_ERRORS = 0x00000002
 591
 592     # <https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382%28v=vs.85%29.aspx>
 593     ERROR_FILE_NOT_FOUND = 2
 594
 595     def rename_no_overwrite(source_path, dest_path):
 596         os.rename(source_path, dest_path)
 597
 598     def replace_file(replaced_path, replacement_path, backup_path):
 599         precondition_abspath(replaced_path)
 600         precondition_abspath(replacement_path)
 601         precondition_abspath(backup_path)
 602
 603         r = ReplaceFileW(replaced_path, replacement_path, backup_path,
 604                          REPLACEFILE_IGNORE_MERGE_ERRORS, None, None)
 605         if r == 0:
 606             # The UnableToUnlinkReplacementError case does not happen on Windows;
 607             # all errors should be treated as signalling a conflict.
 608             err = get_last_error()
 609             if err != ERROR_FILE_NOT_FOUND:
 610                 raise ConflictError("WinError: %s" % (WinError(err),))
 611
 612             try:
 613                 rename_no_overwrite(replacement_path, replaced_path)
 614             except EnvironmentError:
 615                 reraise(ConflictError)
 616 else:
 617     def rename_no_overwrite(source_path, dest_path):
 618         # link will fail with EEXIST if there is already something at dest_path.
 619         os.link(source_path, dest_path)
 620         try:
 621             os.unlink(source_path)
 622         except EnvironmentError:
 623             reraise(UnableToUnlinkReplacementError)
 624
 625     def replace_file(replaced_path, replacement_path, backup_path):
 626         precondition_abspath(replaced_path)
 627         precondition_abspath(replacement_path)
 628         precondition_abspath(backup_path)
 629
 630         if not os.path.exists(replacement_path):
 631             raise ConflictError("Replacement file not found: %r" % (replacement_path,))
 632
 633         try:
 634             os.rename(replaced_path, backup_path)
 635         except OSError as e:
 636             if e.errno != ENOENT:
 637                 raise
 638         try:
 639             rename_no_overwrite(replacement_path, replaced_path)
 640         except EnvironmentError:
 641             reraise(ConflictError)
 642
 643 PathInfo = namedtuple('PathInfo', 'isdir isfile islink exists size mtime ctime')
 644
 645 def get_pathinfo(path_u, now=None):
 646     try:
 647         statinfo = os.lstat(path_u)
 648         mode = statinfo.st_mode
 649         return PathInfo(isdir =stat.S_ISDIR(mode),
 650                         isfile=stat.S_ISREG(mode),
 651                         islink=stat.S_ISLNK(mode),
 652                         exists=True,
 653                         size  =statinfo.st_size,
 654                         mtime =statinfo.st_mtime,
 655                         ctime =statinfo.st_ctime,
 656                        )
 657     except OSError as e:
 658         if e.errno == ENOENT:
 659             if now is None:
 660                 now = time.time()
 661             return PathInfo(isdir =False,
 662                             isfile=False,
 663                             islink=False,
 664                             exists=False,
 665                             size  =None,
 666                             mtime =now,
 667                             ctime =now,
 668                            )
 669         raise