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, LPVOID, HANDLE
  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         abspath = os.path.realpath(path)
 550         if abspath.startswith("\\\\?\\"):
 551             abspath = abspath[4 :]
 552         drive = os.path.splitdrive(abspath)[0]
 553
 554         print "flushing %r" % (drive,)
 555         hVolume = CreateFileW(u"\\\\.\\" + drive,
 556                               GENERIC_WRITE,
 557                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 558                               None,
 559                               OPEN_EXISTING,
 560                               0,
 561                               None
 562                              )
 563         if hVolume == INVALID_HANDLE_VALUE:
 564             raise WinError(get_last_error())
 565
 566         if FlushFileBuffers(hVolume) == 0:
 567             raise WinError(get_last_error())
 568
 569         CloseHandle(hVolume)
 570 else:
 571     def flush_volume(path):
 572         # use sync()?
 573         pass
 574
 575
 576 class ConflictError(Exception):
 577     pass
 578
 579 class UnableToUnlinkReplacementError(Exception):
 580     pass
 581
 582 def reraise(wrapper):
 583     _, exc, tb = sys.exc_info()
 584     wrapper_exc = wrapper("%s: %s" % (exc.__class__.__name__, exc))
 585     raise wrapper_exc.__class__, wrapper_exc, tb
 586
 587 if sys.platform == "win32":
 588     # <https://msdn.microsoft.com/en-us/library/windows/desktop/aa365512%28v=vs.85%29.aspx>
 589     ReplaceFileW = WINFUNCTYPE(
 590         BOOL,  LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID,
 591         use_last_error=True
 592     )(("ReplaceFileW", windll.kernel32))
 593
 594     REPLACEFILE_IGNORE_MERGE_ERRORS = 0x00000002
 595
 596     # <https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382%28v=vs.85%29.aspx>
 597     ERROR_FILE_NOT_FOUND = 2
 598
 599     def rename_no_overwrite(source_path, dest_path):
 600         os.rename(source_path, dest_path)
 601
 602     def replace_file(replaced_path, replacement_path, backup_path):
 603         precondition_abspath(replaced_path)
 604         precondition_abspath(replacement_path)
 605         precondition_abspath(backup_path)
 606
 607         r = ReplaceFileW(replaced_path, replacement_path, backup_path,
 608                          REPLACEFILE_IGNORE_MERGE_ERRORS, None, None)
 609         if r == 0:
 610             # The UnableToUnlinkReplacementError case does not happen on Windows;
 611             # all errors should be treated as signalling a conflict.
 612             err = get_last_error()
 613             if err != ERROR_FILE_NOT_FOUND:
 614                 raise ConflictError("WinError: %s" % (WinError(err),))
 615
 616             try:
 617                 rename_no_overwrite(replacement_path, replaced_path)
 618             except EnvironmentError:
 619                 reraise(ConflictError)
 620 else:
 621     def rename_no_overwrite(source_path, dest_path):
 622         # link will fail with EEXIST if there is already something at dest_path.
 623         os.link(source_path, dest_path)
 624         try:
 625             os.unlink(source_path)
 626         except EnvironmentError:
 627             reraise(UnableToUnlinkReplacementError)
 628
 629     def replace_file(replaced_path, replacement_path, backup_path):
 630         precondition_abspath(replaced_path)
 631         precondition_abspath(replacement_path)
 632         precondition_abspath(backup_path)
 633
 634         if not os.path.exists(replacement_path):
 635             raise ConflictError("Replacement file not found: %r" % (replacement_path,))
 636
 637         try:
 638             os.rename(replaced_path, backup_path)
 639         except OSError as e:
 640             if e.errno != ENOENT:
 641                 raise
 642         try:
 643             rename_no_overwrite(replacement_path, replaced_path)
 644         except EnvironmentError:
 645             reraise(ConflictError)
 646
 647 PathInfo = namedtuple('PathInfo', 'isdir isfile islink exists size mtime ctime')
 648
 649 def get_pathinfo(path_u, now=None):
 650     try:
 651         statinfo = os.lstat(path_u)
 652         mode = statinfo.st_mode
 653         return PathInfo(isdir =stat.S_ISDIR(mode),
 654                         isfile=stat.S_ISREG(mode),
 655                         islink=stat.S_ISLNK(mode),
 656                         exists=True,
 657                         size  =statinfo.st_size,
 658                         mtime =statinfo.st_mtime,
 659                         ctime =statinfo.st_ctime,
 660                        )
 661     except OSError as e:
 662         if e.errno == ENOENT:
 663             if now is None:
 664                 now = time.time()
 665             return PathInfo(isdir =False,
 666                             isfile=False,
 667                             islink=False,
 668                             exists=False,
 669                             size  =None,
 670                             mtime =now,
 671                             ctime =now,
 672                            )
 673         raise