/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Merge 2.0 into 2.1 including fixes for #262450, #373898, #498409

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
17
17
import os
18
18
import re
19
19
import stat
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
 
21
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
21
22
import sys
22
23
import time
23
 
import codecs
 
24
import warnings
24
25
 
25
26
from bzrlib.lazy_import import lazy_import
26
27
lazy_import(globals(), """
 
28
import codecs
27
29
from datetime import datetime
28
30
import errno
29
31
from ntpath import (abspath as _nt_abspath,
37
39
from shutil import (
38
40
    rmtree,
39
41
    )
40
 
import socket
 
42
import signal
41
43
import subprocess
42
44
import tempfile
43
45
from tempfile import (
48
50
from bzrlib import (
49
51
    cache_utf8,
50
52
    errors,
51
 
    trace,
52
53
    win32utils,
53
54
    )
54
55
""")
55
56
 
56
 
from bzrlib.symbol_versioning import (
57
 
    deprecated_function,
58
 
    deprecated_in,
59
 
    )
60
 
 
61
57
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
62
58
# of 2.5
63
59
if sys.version_info < (2, 5):
186
182
    try:
187
183
        return _kind_marker_map[kind]
188
184
    except KeyError:
189
 
        # Slightly faster than using .get(, '') when the common case is that
190
 
        # kind will be found
191
 
        return ''
 
185
        raise errors.BzrError('invalid file kind %r' % kind)
192
186
 
193
187
 
194
188
lexists = getattr(os.path, 'lexists', None)
360
354
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
361
355
 
362
356
 
363
 
def _add_rename_error_details(e, old, new):
364
 
    new_e = OSError(e.errno, "failed to rename %s to %s: %s"
365
 
        % (old, new, e.strerror))
366
 
    new_e.filename = old
367
 
    new_e.to_filename = new
368
 
    return new_e
369
 
 
370
 
 
371
357
def _win32_rename(old, new):
372
358
    """We expect to be able to atomically replace 'new' with old.
373
359
 
375
361
    and then deleted.
376
362
    """
377
363
    try:
378
 
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
 
364
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
379
365
    except OSError, e:
380
366
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
381
367
            # If we try to rename a non-existant file onto cwd, we get
386
372
        raise
387
373
 
388
374
 
389
 
def _wrapped_rename(old, new):
390
 
    """Rename a file or directory"""
391
 
    try:
392
 
        os.rename(old, new)
393
 
    except (IOError, OSError), e:
394
 
        # this is eventually called by all rename-like functions, so should 
395
 
        # catch all of them
396
 
        raise _add_rename_error_details(e, old, new)
397
 
 
398
 
 
399
375
def _mac_getcwd():
400
376
    return unicodedata.normalize('NFC', os.getcwdu())
401
377
 
406
382
realpath = _posix_realpath
407
383
pathjoin = os.path.join
408
384
normpath = os.path.normpath
409
 
rename = _wrapped_rename # overridden below on win32
410
385
getcwd = os.getcwdu
 
386
rename = os.rename
411
387
dirname = os.path.dirname
412
388
basename = os.path.basename
413
389
split = os.path.split
1147
1123
 
1148
1124
 
1149
1125
def relpath(base, path):
1150
 
    """Return path relative to base, or raise PathNotChild exception.
 
1126
    """Return path relative to base, or raise exception.
1151
1127
 
1152
1128
    The path may be either an absolute path or a path relative to the
1153
1129
    current working directory.
1155
1131
    os.path.commonprefix (python2.4) has a bad bug that it works just
1156
1132
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
1157
1133
    avoids that problem.
1158
 
 
1159
 
    NOTE: `base` should not have a trailing slash otherwise you'll get
1160
 
    PathNotChild exceptions regardless of `path`.
1161
1134
    """
1162
1135
 
1163
1136
    if len(base) < MIN_ABS_PATHLENGTH:
1383
1356
        False)`).  May be ignored if the feature is not available on this
1384
1357
        platform or Python version.
1385
1358
    """
1386
 
    try:
1387
 
        import signal
1388
 
        siginterrupt = signal.siginterrupt
1389
 
    except ImportError:
1390
 
        # This python implementation doesn't provide signal support, hence no
1391
 
        # handler exists
1392
 
        return None
1393
 
    except AttributeError:
1394
 
        # siginterrupt doesn't exist on this platform, or for this version
1395
 
        # of Python.
1396
 
        siginterrupt = lambda signum, flag: None
 
1359
    old_handler = signal.signal(signum, handler)
1397
1360
    if restart_syscall:
1398
 
        def sig_handler(*args):
1399
 
            # Python resets the siginterrupt flag when a signal is
1400
 
            # received.  <http://bugs.python.org/issue8354>
1401
 
            # As a workaround for some cases, set it back the way we want it.
 
1361
        try:
 
1362
            siginterrupt = signal.siginterrupt
 
1363
        except AttributeError: # siginterrupt doesn't exist on this platform, or for this version of
 
1364
            # Python.
 
1365
            pass
 
1366
        else:
1402
1367
            siginterrupt(signum, False)
1403
 
            # Now run the handler function passed to set_signal_handler.
1404
 
            handler(*args)
1405
 
    else:
1406
 
        sig_handler = handler
1407
 
    old_handler = signal.signal(signum, sig_handler)
1408
 
    if restart_syscall:
1409
 
        siginterrupt(signum, False)
1410
1368
    return old_handler
1411
1369
 
1412
1370
 
1506
1464
 
1507
1465
 
1508
1466
_registered_sigwinch = False
 
1467
 
1509
1468
def watch_sigwinch():
1510
 
    """Register for SIGWINCH, once and only once.
1511
 
 
1512
 
    Do nothing if the signal module is not available.
1513
 
    """
 
1469
    """Register for SIGWINCH, once and only once."""
1514
1470
    global _registered_sigwinch
1515
1471
    if not _registered_sigwinch:
1516
 
        try:
1517
 
            import signal
1518
 
            if getattr(signal, "SIGWINCH", None) is not None:
1519
 
                set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1520
 
        except ImportError:
1521
 
            # python doesn't provide signal support, nothing we can do about it
 
1472
        if sys.platform == 'win32':
 
1473
            # Martin (gz) mentioned WINDOW_BUFFER_SIZE_RECORD from
 
1474
            # ReadConsoleInput but I've no idea how to plug that in
 
1475
            # the current design -- vila 20091216
1522
1476
            pass
 
1477
        else:
 
1478
            set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1523
1479
        _registered_sigwinch = True
1524
1480
 
1525
1481
 
1846
1802
            real_handlers[kind](abspath, relpath)
1847
1803
 
1848
1804
 
1849
 
def copy_ownership_from_path(dst, src=None):
1850
 
    """Copy usr/grp ownership from src file/dir to dst file/dir.
1851
 
 
1852
 
    If src is None, the containing directory is used as source. If chown
1853
 
    fails, the error is ignored and a warning is printed.
1854
 
    """
1855
 
    chown = getattr(os, 'chown', None)
1856
 
    if chown is None:
1857
 
        return
1858
 
 
1859
 
    if src == None:
1860
 
        src = os.path.dirname(dst)
1861
 
        if src == '':
1862
 
            src = '.'
1863
 
 
1864
 
    try:
1865
 
        s = os.stat(src)
1866
 
        chown(dst, s.st_uid, s.st_gid)
1867
 
    except OSError, e:
1868
 
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1869
 
 
1870
 
 
1871
1805
def path_prefix_key(path):
1872
1806
    """Generate a prefix-order path key for path.
1873
1807
 
1973
1907
        return socket.gethostname().decode(get_user_encoding())
1974
1908
 
1975
1909
 
1976
 
# We must not read/write any more than 64k at a time from/to a socket so we
1977
 
# don't risk "no buffer space available" errors on some platforms.  Windows in
1978
 
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
1979
 
# data at once.
1980
 
MAX_SOCKET_CHUNK = 64 * 1024
1981
 
 
1982
 
def read_bytes_from_socket(sock, report_activity=None,
1983
 
        max_read_size=MAX_SOCKET_CHUNK):
1984
 
    """Read up to max_read_size of bytes from sock and notify of progress.
1985
 
 
1986
 
    Translates "Connection reset by peer" into file-like EOF (return an
1987
 
    empty string rather than raise an error), and repeats the recv if
1988
 
    interrupted by a signal.
1989
 
    """
1990
 
    while 1:
1991
 
        try:
1992
 
            bytes = sock.recv(max_read_size)
1993
 
        except socket.error, e:
1994
 
            eno = e.args[0]
1995
 
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
1996
 
                # The connection was closed by the other side.  Callers expect
1997
 
                # an empty string to signal end-of-stream.
1998
 
                return ""
1999
 
            elif eno == errno.EINTR:
2000
 
                # Retry the interrupted recv.
2001
 
                continue
2002
 
            raise
2003
 
        else:
2004
 
            if report_activity is not None:
2005
 
                report_activity(len(bytes), 'read')
2006
 
            return bytes
2007
 
 
2008
 
 
2009
 
def recv_all(socket, count):
 
1910
def recv_all(socket, bytes):
2010
1911
    """Receive an exact number of bytes.
2011
1912
 
2012
1913
    Regular Socket.recv() may return less than the requested number of bytes,
2013
 
    depending on what's in the OS buffer.  MSG_WAITALL is not available
 
1914
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
2014
1915
    on all platforms, but this should work everywhere.  This will return
2015
1916
    less than the requested amount if the remote end closes.
2016
1917
 
2017
1918
    This isn't optimized and is intended mostly for use in testing.
2018
1919
    """
2019
1920
    b = ''
2020
 
    while len(b) < count:
2021
 
        new = read_bytes_from_socket(socket, None, count - len(b))
 
1921
    while len(b) < bytes:
 
1922
        new = until_no_eintr(socket.recv, bytes - len(b))
2022
1923
        if new == '':
2023
1924
            break # eof
2024
1925
        b += new
2025
1926
    return b
2026
1927
 
2027
1928
 
2028
 
def send_all(sock, bytes, report_activity=None):
 
1929
def send_all(socket, bytes, report_activity=None):
2029
1930
    """Send all bytes on a socket.
2030
 
 
2031
 
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2032
 
    some platforms, and catches EINTR which may be thrown if the send is
2033
 
    interrupted by a signal.
2034
 
 
2035
 
    This is preferred to socket.sendall(), because it avoids portability bugs
2036
 
    and provides activity reporting.
2037
 
 
 
1931
 
 
1932
    Regular socket.sendall() can give socket error 10053 on Windows.  This
 
1933
    implementation sends no more than 64k at a time, which avoids this problem.
 
1934
 
2038
1935
    :param report_activity: Call this as bytes are read, see
2039
1936
        Transport._report_activity
2040
1937
    """
2041
 
    sent_total = 0
2042
 
    byte_count = len(bytes)
2043
 
    while sent_total < byte_count:
2044
 
        try:
2045
 
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2046
 
        except socket.error, e:
2047
 
            if e.args[0] != errno.EINTR:
2048
 
                raise
2049
 
        else:
2050
 
            sent_total += sent
2051
 
            report_activity(sent, 'write')
 
1938
    chunk_size = 2**16
 
1939
    for pos in xrange(0, len(bytes), chunk_size):
 
1940
        block = bytes[pos:pos+chunk_size]
 
1941
        if report_activity is not None:
 
1942
            report_activity(len(block), 'write')
 
1943
        until_no_eintr(socket.sendall, block)
2052
1944
 
2053
1945
 
2054
1946
def dereference_path(path):
2125
2017
 
2126
2018
 
2127
2019
def until_no_eintr(f, *a, **kw):
2128
 
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2129
 
    
2130
 
    WARNING: you must be certain that it is safe to retry the call repeatedly
2131
 
    if EINTR does occur.  This is typically only true for low-level operations
2132
 
    like os.read.  If in any doubt, don't use this.
2133
 
 
2134
 
    Keep in mind that this is not a complete solution to EINTR.  There is
2135
 
    probably code in the Python standard library and other dependencies that
2136
 
    may encounter EINTR if a signal arrives (and there is signal handler for
2137
 
    that signal).  So this function can reduce the impact for IO that bzrlib
2138
 
    directly controls, but it is not a complete solution.
2139
 
    """
 
2020
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
2140
2021
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
2141
2022
    while True:
2142
2023
        try:
2146
2027
                continue
2147
2028
            raise
2148
2029
 
2149
 
 
2150
2030
def re_compile_checked(re_string, flags=0, where=""):
2151
2031
    """Return a compiled re, or raise a sensible error.
2152
2032