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, DWORD, LPCWSTR, LPWSTR
  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):
 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     """
 292     if not isinstance(path, unicode):
 293         raise AssertionError("paths must be Unicode strings")
 294     if base is not None:
 295         precondition_abspath(base)
 296
 297     path = expanduser(path)
 298
 299     if _getfullpathname:
 300         # On Windows, os.path.isabs will incorrectly return True
 301         # for paths without a drive letter (that are not UNC paths),
 302         # e.g. "\\". See <http://bugs.python.org/issue1669539>.
 303         try:
 304             if base is None:
 305                 path = _getfullpathname(path or u".")
 306             else:
 307                 path = _getfullpathname(os.path.join(base, path))
 308         except OSError:
 309             pass
 310
 311     if not os.path.isabs(path):
 312         if base is None:
 313             path = os.path.join(os.getcwdu(), path)
 314         else:
 315             path = os.path.join(base, path)
 316
 317     # We won't hit <http://bugs.python.org/issue5827> because
 318     # there is always at least one Unicode path component.
 319     path = os.path.normpath(path)
 320
 321     if sys.platform == "win32":
 322         path = to_windows_long_path(path)
 323
 324     return path
 325
 326 def to_windows_long_path(path):
 327     # '/' is normally a perfectly valid path component separator in Windows.
 328     # However, when using the "\\?\" syntax it is not recognized, so we
 329     # replace it with '\' here.
 330     path = path.replace(u"/", u"\\")
 331
 332     # Note that other normalizations such as removing '.' and '..' should
 333     # be done outside this function.
 334
 335     if path.startswith(u"\\\\?\\") or path.startswith(u"\\\\.\\"):
 336         return path
 337     elif path.startswith(u"\\\\"):
 338         return u"\\\\?\\UNC\\" + path[2 :]
 339     else:
 340         return u"\\\\?\\" + path
 341
 342
 343 have_GetDiskFreeSpaceExW = False
 344 if sys.platform == "win32":
 345     # <http://msdn.microsoft.com/en-us/library/windows/desktop/ms683188%28v=vs.85%29.aspx>
 346     GetEnvironmentVariableW = WINFUNCTYPE(
 347         DWORD,  LPCWSTR, LPWSTR, DWORD,
 348         use_last_error=True
 349     )(("GetEnvironmentVariableW", windll.kernel32))
 350
 351     try:
 352         # <http://msdn.microsoft.com/en-us/library/aa383742%28v=VS.85%29.aspx>
 353         PULARGE_INTEGER = POINTER(c_ulonglong)
 354
 355         # <http://msdn.microsoft.com/en-us/library/aa364937%28VS.85%29.aspx>
 356         GetDiskFreeSpaceExW = WINFUNCTYPE(
 357             BOOL,  LPCWSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER,
 358             use_last_error=True
 359         )(("GetDiskFreeSpaceExW", windll.kernel32))
 360
 361         have_GetDiskFreeSpaceExW = True
 362     except Exception:
 363         import traceback
 364         traceback.print_exc()
 365
 366 def expanduser(path):
 367     # os.path.expanduser is hopelessly broken for Unicode paths on Windows (ticket #1674).
 368     if sys.platform == "win32":
 369         return windows_expanduser(path)
 370     else:
 371         return os.path.expanduser(path)
 372
 373 def windows_expanduser(path):
 374     if not path.startswith('~'):
 375         return path
 376
 377     home_dir = windows_getenv(u'USERPROFILE')
 378     if home_dir is None:
 379         home_drive = windows_getenv(u'HOMEDRIVE')
 380         home_path = windows_getenv(u'HOMEPATH')
 381         if home_drive is None or home_path is None:
 382             raise OSError("Could not find home directory: neither %USERPROFILE% nor (%HOMEDRIVE% and %HOMEPATH%) are set.")
 383         home_dir = os.path.join(home_drive, home_path)
 384
 385     if path == '~':
 386         return home_dir
 387     elif path.startswith('~/') or path.startswith('~\\'):
 388         return os.path.join(home_dir, path[2 :])
 389     else:
 390         return path
 391
 392 # <https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382%28v=vs.85%29.aspx>
 393 ERROR_ENVVAR_NOT_FOUND = 203
 394
 395 def windows_getenv(name):
 396     # Based on <http://stackoverflow.com/questions/2608200/problems-with-umlauts-in-python-appdata-environvent-variable/2608368#2608368>,
 397     # with improved error handling. Returns None if there is no enivronment variable of the given name.
 398     if not isinstance(name, unicode):
 399         raise AssertionError("name must be Unicode")
 400
 401     n = GetEnvironmentVariableW(name, None, 0)
 402     # GetEnvironmentVariableW returns DWORD, so n cannot be negative.
 403     if n == 0:
 404         err = get_last_error()
 405         if err == ERROR_ENVVAR_NOT_FOUND:
 406             return None
 407         raise OSError("WinError: %s\n attempting to read size of environment variable %r"
 408                       % (WinError(err), name))
 409     if n == 1:
 410         # Avoid an ambiguity between a zero-length string and an error in the return value of the
 411         # call to GetEnvironmentVariableW below.
 412         return u""
 413
 414     buf = create_unicode_buffer(u'\0'*n)
 415     retval = GetEnvironmentVariableW(name, buf, n)
 416     if retval == 0:
 417         err = get_last_error()
 418         if err == ERROR_ENVVAR_NOT_FOUND:
 419             return None
 420         raise OSError("WinError: %s\n attempting to read environment variable %r"
 421                       % (WinError(err), name))
 422     if retval >= n:
 423         raise OSError("Unexpected result %d (expected less than %d) from GetEnvironmentVariableW attempting to read environment variable %r"
 424                       % (retval, n, name))
 425
 426     return buf.value
 427
 428 def get_disk_stats(whichdir, reserved_space=0):
 429     """Return disk statistics for the storage disk, in the form of a dict
 430     with the following fields.
 431       total:            total bytes on disk
 432       free_for_root:    bytes actually free on disk
 433       free_for_nonroot: bytes free for "a non-privileged user" [Unix] or
 434                           the current user [Windows]; might take into
 435                           account quotas depending on platform
 436       used:             bytes used on disk
 437       avail:            bytes available excluding reserved space
 438     An AttributeError can occur if the OS has no API to get disk information.
 439     An EnvironmentError can occur if the OS call fails.
 440
 441     whichdir is a directory on the filesystem in question -- the
 442     answer is about the filesystem, not about the directory, so the
 443     directory is used only to specify which filesystem.
 444
 445     reserved_space is how many bytes to subtract from the answer, so
 446     you can pass how many bytes you would like to leave unused on this
 447     filesystem as reserved_space.
 448     """
 449
 450     if have_GetDiskFreeSpaceExW:
 451         # If this is a Windows system and GetDiskFreeSpaceExW is available, use it.
 452         # (This might put up an error dialog unless
 453         # SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX) has been called,
 454         # which we do in allmydata.windows.fixups.initialize().)
 455
 456         n_free_for_nonroot = c_ulonglong(0)
 457         n_total            = c_ulonglong(0)
 458         n_free_for_root    = c_ulonglong(0)
 459         retval = GetDiskFreeSpaceExW(whichdir, byref(n_free_for_nonroot),
 460                                                byref(n_total),
 461                                                byref(n_free_for_root))
 462         if retval == 0:
 463             raise OSError("WinError: %s\n attempting to get disk statistics for %r"
 464                           % (WinError(get_last_error()), whichdir))
 465         free_for_nonroot = n_free_for_nonroot.value
 466         total            = n_total.value
 467         free_for_root    = n_free_for_root.value
 468     else:
 469         # For Unix-like systems.
 470         # <http://docs.python.org/library/os.html#os.statvfs>
 471         # <http://opengroup.org/onlinepubs/7990989799/xsh/fstatvfs.html>
 472         # <http://opengroup.org/onlinepubs/7990989799/xsh/sysstatvfs.h.html>
 473         s = os.statvfs(whichdir)
 474
 475         # on my mac laptop:
 476         #  statvfs(2) is a wrapper around statfs(2).
 477         #    statvfs.f_frsize = statfs.f_bsize :
 478         #     "minimum unit of allocation" (statvfs)
 479         #     "fundamental file system block size" (statfs)
 480         #    statvfs.f_bsize = statfs.f_iosize = stat.st_blocks : preferred IO size
 481         # on an encrypted home directory ("FileVault"), it gets f_blocks
 482         # wrong, and s.f_blocks*s.f_frsize is twice the size of my disk,
 483         # but s.f_bavail*s.f_frsize is correct
 484
 485         total = s.f_frsize * s.f_blocks
 486         free_for_root = s.f_frsize * s.f_bfree
 487         free_for_nonroot = s.f_frsize * s.f_bavail
 488
 489     # valid for all platforms:
 490     used = total - free_for_root
 491     avail = max(free_for_nonroot - reserved_space, 0)
 492
 493     return { 'total': total,
 494              'free_for_root': free_for_root,
 495              'free_for_nonroot': free_for_nonroot,
 496              'used': used,
 497              'avail': avail,
 498            }
 499
 500 def get_available_space(whichdir, reserved_space):
 501     """Returns available space for share storage in bytes, or None if no
 502     API to get this information is available.
 503
 504     whichdir is a directory on the filesystem in question -- the
 505     answer is about the filesystem, not about the directory, so the
 506     directory is used only to specify which filesystem.
 507
 508     reserved_space is how many bytes to subtract from the answer, so
 509     you can pass how many bytes you would like to leave unused on this
 510     filesystem as reserved_space.
 511     """
 512     try:
 513         return get_disk_stats(whichdir, reserved_space)['avail']
 514     except AttributeError:
 515         return None
 516     except EnvironmentError:
 517         log.msg("OS call to get disk statistics failed")
 518         return 0
 519
 520
 521 if sys.platform == "win32":
 522     from ctypes.wintypes import BOOL, HANDLE, DWORD, LPCWSTR, LPVOID, WinError, get_last_error
 523
 524     # <http://msdn.microsoft.com/en-us/library/aa363858%28v=vs.85%29.aspx>
 525     CreateFileW = WINFUNCTYPE(HANDLE, LPCWSTR, DWORD, DWORD, LPVOID, DWORD, DWORD, HANDLE) \
 526                       (("CreateFileW", windll.kernel32))
 527
 528     GENERIC_WRITE        = 0x40000000
 529     FILE_SHARE_READ      = 0x00000001
 530     FILE_SHARE_WRITE     = 0x00000002
 531     OPEN_EXISTING        = 3
 532     INVALID_HANDLE_VALUE = 0xFFFFFFFF
 533
 534     # <http://msdn.microsoft.com/en-us/library/aa364439%28v=vs.85%29.aspx>
 535     FlushFileBuffers = WINFUNCTYPE(BOOL, HANDLE)(("FlushFileBuffers", windll.kernel32))
 536
 537     # <http://msdn.microsoft.com/en-us/library/ms724211%28v=vs.85%29.aspx>
 538     CloseHandle = WINFUNCTYPE(BOOL, HANDLE)(("CloseHandle", windll.kernel32))
 539
 540     # <http://social.msdn.microsoft.com/forums/en-US/netfxbcl/thread/4465cafb-f4ed-434f-89d8-c85ced6ffaa8/>
 541     def flush_volume(path):
 542         drive = os.path.splitdrive(os.path.realpath(path))[0]
 543
 544         hVolume = CreateFileW(u"\\\\.\\" + drive,
 545                               GENERIC_WRITE,
 546                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 547                               None,
 548                               OPEN_EXISTING,
 549                               0,
 550                               None
 551                              )
 552         if hVolume == INVALID_HANDLE_VALUE:
 553             raise WinError()
 554
 555         if FlushFileBuffers(hVolume) == 0:
 556             raise WinError()
 557
 558         CloseHandle(hVolume)
 559 else:
 560     def flush_volume(path):
 561         # use sync()?
 562         pass
 563
 564
 565 class ConflictError(Exception):
 566     pass
 567
 568 class UnableToUnlinkReplacementError(Exception):
 569     pass
 570
 571 def reraise(wrapper):
 572     _, exc, tb = sys.exc_info()
 573     wrapper_exc = wrapper("%s: %s" % (exc.__class__.__name__, exc))
 574     raise wrapper_exc.__class__, wrapper_exc, tb
 575
 576 if sys.platform == "win32":
 577     from ctypes import WINFUNCTYPE, windll, WinError, get_last_error
 578     from ctypes.wintypes import BOOL, DWORD, LPCWSTR, LPVOID
 579
 580     # <https://msdn.microsoft.com/en-us/library/windows/desktop/aa365512%28v=vs.85%29.aspx>
 581     ReplaceFileW = WINFUNCTYPE(
 582         BOOL,
 583           LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID,
 584         use_last_error=True
 585       )(("ReplaceFileW", windll.kernel32))
 586
 587     REPLACEFILE_IGNORE_MERGE_ERRORS = 0x00000002
 588
 589     def rename_no_overwrite(source_path, dest_path):
 590         os.rename(source_path, dest_path)
 591
 592     def replace_file(replaced_path, replacement_path, backup_path):
 593         precondition_abspath(replaced_path)
 594         precondition_abspath(replacement_path)
 595         precondition_abspath(backup_path)
 596
 597         r = ReplaceFileW(replaced_path, replacement_path, backup_path,
 598                          REPLACEFILE_IGNORE_MERGE_ERRORS, None, None)
 599         if r == 0:
 600             # The UnableToUnlinkReplacementError case does not happen on Windows;
 601             # all errors should be treated as signalling a conflict.
 602             err = get_last_error()
 603             raise ConflictError("WinError: %s" % (WinError(err)))
 604 else:
 605     def rename_no_overwrite(source_path, dest_path):
 606         # link will fail with EEXIST if there is already something at dest_path.
 607         os.link(source_path, dest_path)
 608         try:
 609             os.unlink(source_path)
 610         except EnvironmentError:
 611             reraise(UnableToUnlinkReplacementError)
 612
 613     def replace_file(replaced_path, replacement_path, backup_path):
 614         precondition_abspath(replaced_path)
 615         precondition_abspath(replacement_path)
 616         precondition_abspath(backup_path)
 617
 618         if not os.path.exists(replacement_path):
 619             raise ConflictError("Replacement file not found: %r" % (replacement_path,))
 620
 621         try:
 622             os.rename(replaced_path, backup_path)
 623         except OSError as e:
 624             if e.errno != ENOENT:
 625                 raise
 626         try:
 627             rename_no_overwrite(replacement_path, replaced_path)
 628         except EnvironmentError:
 629             reraise(ConflictError)
 630
 631 PathInfo = namedtuple('PathInfo', 'isdir isfile islink exists size mtime ctime')
 632
 633 def get_pathinfo(path_u, now=None):
 634     try:
 635         statinfo = os.lstat(path_u)
 636         mode = statinfo.st_mode
 637         return PathInfo(isdir =stat.S_ISDIR(mode),
 638                         isfile=stat.S_ISREG(mode),
 639                         islink=stat.S_ISLNK(mode),
 640                         exists=True,
 641                         size  =statinfo.st_size,
 642                         mtime =statinfo.st_mtime,
 643                         ctime =statinfo.st_ctime,
 644                        )
 645     except OSError as e:
 646         if e.errno == ENOENT:
 647             if now is None:
 648                 now = time.time()
 649             return PathInfo(isdir =False,
 650                             isfile=False,
 651                             islink=False,
 652                             exists=False,
 653                             size  =None,
 654                             mtime =now,
 655                             ctime =now,
 656                            )
 657         raise