/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

  • Committer: Ian Clatworthy
  • Date: 2010-03-26 07:58:58 UTC
  • mto: (5120.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5121.
  • Revision ID: ian.clatworthy@canonical.com-20100326075858-umm5rlmaxkf9it9c
it's sqlite3, not just sqlite

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
24
import codecs
 
25
import warnings
24
26
 
25
27
from bzrlib.lazy_import import lazy_import
26
28
lazy_import(globals(), """
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,
 
53
    win32utils,
51
54
    trace,
52
 
    win32utils,
53
55
    )
 
56
 
54
57
""")
55
58
 
56
 
from bzrlib.symbol_versioning import (
57
 
    deprecated_function,
58
 
    deprecated_in,
59
 
    )
60
 
 
61
59
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
62
60
# of 2.5
63
61
if sys.version_info < (2, 5):
360
358
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
361
359
 
362
360
 
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
361
def _win32_rename(old, new):
372
362
    """We expect to be able to atomically replace 'new' with old.
373
363
 
375
365
    and then deleted.
376
366
    """
377
367
    try:
378
 
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
 
368
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
379
369
    except OSError, e:
380
370
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
381
371
            # If we try to rename a non-existant file onto cwd, we get
386
376
        raise
387
377
 
388
378
 
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
379
def _mac_getcwd():
400
380
    return unicodedata.normalize('NFC', os.getcwdu())
401
381
 
406
386
realpath = _posix_realpath
407
387
pathjoin = os.path.join
408
388
normpath = os.path.normpath
409
 
rename = _wrapped_rename # overridden below on win32
410
389
getcwd = os.getcwdu
 
390
rename = os.rename
411
391
dirname = os.path.dirname
412
392
basename = os.path.basename
413
393
split = os.path.split
1147
1127
 
1148
1128
 
1149
1129
def relpath(base, path):
1150
 
    """Return path relative to base, or raise PathNotChild exception.
 
1130
    """Return path relative to base, or raise exception.
1151
1131
 
1152
1132
    The path may be either an absolute path or a path relative to the
1153
1133
    current working directory.
1155
1135
    os.path.commonprefix (python2.4) has a bad bug that it works just
1156
1136
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
1157
1137
    avoids that problem.
1158
 
 
1159
 
    NOTE: `base` should not have a trailing slash otherwise you'll get
1160
 
    PathNotChild exceptions regardless of `path`.
1161
1138
    """
1162
1139
 
1163
1140
    if len(base) < MIN_ABS_PATHLENGTH:
1383
1360
        False)`).  May be ignored if the feature is not available on this
1384
1361
        platform or Python version.
1385
1362
    """
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
 
1363
    old_handler = signal.signal(signum, handler)
1397
1364
    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.
 
1365
        try:
 
1366
            siginterrupt = signal.siginterrupt
 
1367
        except AttributeError: # siginterrupt doesn't exist on this platform, or for this version of
 
1368
            # Python.
 
1369
            pass
 
1370
        else:
1402
1371
            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
1372
    return old_handler
1411
1373
 
1412
1374
 
1506
1468
 
1507
1469
 
1508
1470
_registered_sigwinch = False
 
1471
 
1509
1472
def watch_sigwinch():
1510
 
    """Register for SIGWINCH, once and only once.
1511
 
 
1512
 
    Do nothing if the signal module is not available.
1513
 
    """
 
1473
    """Register for SIGWINCH, once and only once."""
1514
1474
    global _registered_sigwinch
1515
1475
    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
 
1476
        if sys.platform == 'win32':
 
1477
            # Martin (gz) mentioned WINDOW_BUFFER_SIZE_RECORD from
 
1478
            # ReadConsoleInput but I've no idea how to plug that in
 
1479
            # the current design -- vila 20091216
1522
1480
            pass
 
1481
        else:
 
1482
            set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1523
1483
        _registered_sigwinch = True
1524
1484
 
1525
1485
 
1846
1806
            real_handlers[kind](abspath, relpath)
1847
1807
 
1848
1808
 
1849
 
def copy_ownership_from_path(dst, src=None):
 
1809
def copy_ownership(dst, src=None):
1850
1810
    """Copy usr/grp ownership from src file/dir to dst file/dir.
1851
1811
 
1852
1812
    If src is None, the containing directory is used as source. If chown
1868
1828
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1869
1829
 
1870
1830
 
 
1831
def mkdir_with_ownership(path, ownership_src=None):
 
1832
    """Create the directory 'path' with specified ownership.
 
1833
 
 
1834
    If ownership_src is given, copies (chown) usr/grp ownership
 
1835
    from 'ownership_src' to 'path'. If ownership_src is None, use the
 
1836
    containing dir ownership.
 
1837
    """
 
1838
    os.mkdir(path)
 
1839
    copy_ownership(path, ownership_src)
 
1840
 
 
1841
 
 
1842
def open_with_ownership(filename, mode='r', bufsize=-1, ownership_src=None):
 
1843
    """Open the file 'filename' with the specified ownership.
 
1844
 
 
1845
    If ownership_src is specified, copy usr/grp ownership from ownership_src
 
1846
    to filename. If ownership_src is None, copy ownership from containing
 
1847
    directory.
 
1848
    Returns the opened file object.
 
1849
    """
 
1850
    f = open(filename, mode, bufsize)
 
1851
    copy_ownership(filename, ownership_src)
 
1852
    return f
 
1853
 
 
1854
 
1871
1855
def path_prefix_key(path):
1872
1856
    """Generate a prefix-order path key for path.
1873
1857
 
1973
1957
        return socket.gethostname().decode(get_user_encoding())
1974
1958
 
1975
1959
 
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):
 
1960
def recv_all(socket, bytes):
2010
1961
    """Receive an exact number of bytes.
2011
1962
 
2012
1963
    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
 
1964
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
2014
1965
    on all platforms, but this should work everywhere.  This will return
2015
1966
    less than the requested amount if the remote end closes.
2016
1967
 
2017
1968
    This isn't optimized and is intended mostly for use in testing.
2018
1969
    """
2019
1970
    b = ''
2020
 
    while len(b) < count:
2021
 
        new = read_bytes_from_socket(socket, None, count - len(b))
 
1971
    while len(b) < bytes:
 
1972
        new = until_no_eintr(socket.recv, bytes - len(b))
2022
1973
        if new == '':
2023
1974
            break # eof
2024
1975
        b += new
2025
1976
    return b
2026
1977
 
2027
1978
 
2028
 
def send_all(sock, bytes, report_activity=None):
 
1979
def send_all(socket, bytes, report_activity=None):
2029
1980
    """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
 
 
 
1981
 
 
1982
    Regular socket.sendall() can give socket error 10053 on Windows.  This
 
1983
    implementation sends no more than 64k at a time, which avoids this problem.
 
1984
 
2038
1985
    :param report_activity: Call this as bytes are read, see
2039
1986
        Transport._report_activity
2040
1987
    """
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')
 
1988
    chunk_size = 2**16
 
1989
    for pos in xrange(0, len(bytes), chunk_size):
 
1990
        block = bytes[pos:pos+chunk_size]
 
1991
        if report_activity is not None:
 
1992
            report_activity(len(block), 'write')
 
1993
        until_no_eintr(socket.sendall, block)
2052
1994
 
2053
1995
 
2054
1996
def dereference_path(path):
2125
2067
 
2126
2068
 
2127
2069
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
 
    """
 
2070
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
2140
2071
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
2141
2072
    while True:
2142
2073
        try:
2146
2077
                continue
2147
2078
            raise
2148
2079
 
2149
 
 
2150
2080
def re_compile_checked(re_string, flags=0, where=""):
2151
2081
    """Return a compiled re, or raise a sensible error.
2152
2082