/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

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
import errno
17
18
import os
18
19
import re
19
20
import stat
20
 
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
 
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
22
21
import sys
23
22
import time
24
23
import codecs
25
 
import warnings
26
24
 
27
25
from bzrlib.lazy_import import lazy_import
28
26
lazy_import(globals(), """
29
27
from datetime import datetime
30
 
import errno
31
 
from ntpath import (abspath as _nt_abspath,
32
 
                    join as _nt_join,
33
 
                    normpath as _nt_normpath,
34
 
                    realpath as _nt_realpath,
35
 
                    splitdrive as _nt_splitdrive,
36
 
                    )
 
28
import getpass
 
29
import ntpath
37
30
import posixpath
 
31
# We need to import both shutil and rmtree as we export the later on posix
 
32
# and need the former on windows
38
33
import shutil
39
 
from shutil import (
40
 
    rmtree,
41
 
    )
42
 
import signal
 
34
from shutil import rmtree
43
35
import socket
44
36
import subprocess
 
37
# We need to import both tempfile and mkdtemp as we export the later on posix
 
38
# and need the former on windows
45
39
import tempfile
46
 
from tempfile import (
47
 
    mkdtemp,
48
 
    )
 
40
from tempfile import mkdtemp
49
41
import unicodedata
50
42
 
51
43
from bzrlib import (
306
298
    running python.exe under cmd.exe return capital C:\\
307
299
    running win32 python inside a cygwin shell returns lowercase c:\\
308
300
    """
309
 
    drive, path = _nt_splitdrive(path)
 
301
    drive, path = ntpath.splitdrive(path)
310
302
    return drive.upper() + path
311
303
 
312
304
 
313
305
def _win32_abspath(path):
314
 
    # Real _nt_abspath doesn't have a problem with a unicode cwd
315
 
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
 
306
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
 
307
    return _win32_fixdrive(ntpath.abspath(unicode(path)).replace('\\', '/'))
316
308
 
317
309
 
318
310
def _win98_abspath(path):
329
321
    #   /path       => C:/path
330
322
    path = unicode(path)
331
323
    # check for absolute path
332
 
    drive = _nt_splitdrive(path)[0]
 
324
    drive = ntpath.splitdrive(path)[0]
333
325
    if drive == '' and path[:2] not in('//','\\\\'):
334
326
        cwd = os.getcwdu()
335
327
        # we cannot simply os.path.join cwd and path
336
328
        # because os.path.join('C:','/path') produce '/path'
337
329
        # and this is incorrect
338
330
        if path[:1] in ('/','\\'):
339
 
            cwd = _nt_splitdrive(cwd)[0]
 
331
            cwd = ntpath.splitdrive(cwd)[0]
340
332
            path = path[1:]
341
333
        path = cwd + '\\' + path
342
 
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
 
334
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
343
335
 
344
336
 
345
337
def _win32_realpath(path):
346
 
    # Real _nt_realpath doesn't have a problem with a unicode cwd
347
 
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
 
338
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
 
339
    return _win32_fixdrive(ntpath.realpath(unicode(path)).replace('\\', '/'))
348
340
 
349
341
 
350
342
def _win32_pathjoin(*args):
351
 
    return _nt_join(*args).replace('\\', '/')
 
343
    return ntpath.join(*args).replace('\\', '/')
352
344
 
353
345
 
354
346
def _win32_normpath(path):
355
 
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
 
347
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
356
348
 
357
349
 
358
350
def _win32_getcwd():
397
389
basename = os.path.basename
398
390
split = os.path.split
399
391
splitext = os.path.splitext
400
 
# These were already imported into local scope
 
392
# These were already lazily imported into local scope
401
393
# mkdtemp = tempfile.mkdtemp
402
394
# rmtree = shutil.rmtree
403
395
 
443
435
    getcwd = _mac_getcwd
444
436
 
445
437
 
446
 
def get_terminal_encoding():
 
438
def get_terminal_encoding(trace=False):
447
439
    """Find the best encoding for printing to the screen.
448
440
 
449
441
    This attempts to check both sys.stdout and sys.stdin to see
455
447
 
456
448
    On my standard US Windows XP, the preferred encoding is
457
449
    cp1252, but the console is cp437
 
450
 
 
451
    :param trace: If True trace the selected encoding via mutter().
458
452
    """
459
453
    from bzrlib.trace import mutter
460
454
    output_encoding = getattr(sys.stdout, 'encoding', None)
462
456
        input_encoding = getattr(sys.stdin, 'encoding', None)
463
457
        if not input_encoding:
464
458
            output_encoding = get_user_encoding()
465
 
            mutter('encoding stdout as osutils.get_user_encoding() %r',
 
459
            if trace:
 
460
                mutter('encoding stdout as osutils.get_user_encoding() %r',
466
461
                   output_encoding)
467
462
        else:
468
463
            output_encoding = input_encoding
469
 
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
464
            if trace:
 
465
                mutter('encoding stdout as sys.stdin encoding %r',
 
466
                    output_encoding)
470
467
    else:
471
 
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
468
        if trace:
 
469
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
472
470
    if output_encoding == 'cp0':
473
471
        # invalid encoding (cp0 means 'no codepage' on Windows)
474
472
        output_encoding = get_user_encoding()
475
 
        mutter('cp0 is invalid encoding.'
 
473
        if trace:
 
474
            mutter('cp0 is invalid encoding.'
476
475
               ' encoding stdout as osutils.get_user_encoding() %r',
477
476
               output_encoding)
478
477
    # check encoding
504
503
def isdir(f):
505
504
    """True if f is an accessible directory."""
506
505
    try:
507
 
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
506
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
508
507
    except OSError:
509
508
        return False
510
509
 
512
511
def isfile(f):
513
512
    """True if f is a regular file."""
514
513
    try:
515
 
        return S_ISREG(os.lstat(f)[ST_MODE])
 
514
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
516
515
    except OSError:
517
516
        return False
518
517
 
519
518
def islink(f):
520
519
    """True if f is a symlink."""
521
520
    try:
522
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
521
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
523
522
    except OSError:
524
523
        return False
525
524
 
865
864
 
866
865
def filesize(f):
867
866
    """Return size of given open file."""
868
 
    return os.fstat(f.fileno())[ST_SIZE]
 
867
    return os.fstat(f.fileno())[stat.ST_SIZE]
869
868
 
870
869
 
871
870
# Define rand_bytes based on platform.
933
932
 
934
933
def parent_directories(filename):
935
934
    """Return the list of parent directories, deepest first.
936
 
    
 
935
 
937
936
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
938
937
    """
939
938
    parents = []
963
962
    # NB: This docstring is just an example, not a doctest, because doctest
964
963
    # currently can't cope with the use of lazy imports in this namespace --
965
964
    # mbp 20090729
966
 
    
 
965
 
967
966
    # This currently doesn't report the failure at the time it occurs, because
968
967
    # they tend to happen very early in startup when we can't check config
969
968
    # files etc, and also we want to report all failures but not spam the user
1039
1038
 
1040
1039
 
1041
1040
def delete_any(path):
1042
 
    """Delete a file, symlink or directory.  
1043
 
    
 
1041
    """Delete a file, symlink or directory.
 
1042
 
1044
1043
    Will delete even if readonly.
1045
1044
    """
1046
1045
    try:
1132
1131
 
1133
1132
 
1134
1133
def relpath(base, path):
1135
 
    """Return path relative to base, or raise exception.
 
1134
    """Return path relative to base, or raise PathNotChild exception.
1136
1135
 
1137
1136
    The path may be either an absolute path or a path relative to the
1138
1137
    current working directory.
1140
1139
    os.path.commonprefix (python2.4) has a bad bug that it works just
1141
1140
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
1142
1141
    avoids that problem.
 
1142
 
 
1143
    NOTE: `base` should not have a trailing slash otherwise you'll get
 
1144
    PathNotChild exceptions regardless of `path`.
1143
1145
    """
1144
1146
 
1145
1147
    if len(base) < MIN_ABS_PATHLENGTH:
1232
1234
    # but for now, we haven't optimized...
1233
1235
    return [canonical_relpath(base, p) for p in paths]
1234
1236
 
 
1237
 
 
1238
def decode_filename(filename):
 
1239
    """Decode the filename using the filesystem encoding
 
1240
 
 
1241
    If it is unicode, it is returned.
 
1242
    Otherwise it is decoded from the the filesystem's encoding. If decoding
 
1243
    fails, a errors.BadFilenameEncoding exception is raised.
 
1244
    """
 
1245
    if type(filename) is unicode:
 
1246
        return filename
 
1247
    try:
 
1248
        return filename.decode(_fs_enc)
 
1249
    except UnicodeDecodeError:
 
1250
        raise errors.BadFilenameEncoding(filename, _fs_enc)
 
1251
 
 
1252
 
1235
1253
def safe_unicode(unicode_or_utf8_string):
1236
1254
    """Coerce unicode_or_utf8_string into unicode.
1237
1255
 
1320
1338
def normalizes_filenames():
1321
1339
    """Return True if this platform normalizes unicode filenames.
1322
1340
 
1323
 
    Mac OSX does, Windows/Linux do not.
 
1341
    Only Mac OSX.
1324
1342
    """
1325
1343
    return _platform_normalizes_filenames
1326
1344
 
1331
1349
    On platforms where the system normalizes filenames (Mac OSX),
1332
1350
    you can access a file by any path which will normalize correctly.
1333
1351
    On platforms where the system does not normalize filenames
1334
 
    (Windows, Linux), you have to access a file by its exact path.
 
1352
    (everything else), you have to access a file by its exact path.
1335
1353
 
1336
1354
    Internally, bzr only supports NFC normalization, since that is
1337
1355
    the standard for XML documents.
1366
1384
        platform or Python version.
1367
1385
    """
1368
1386
    try:
 
1387
        import signal
1369
1388
        siginterrupt = signal.siginterrupt
 
1389
    except ImportError:
 
1390
        # This python implementation doesn't provide signal support, hence no
 
1391
        # handler exists
 
1392
        return None
1370
1393
    except AttributeError:
1371
1394
        # siginterrupt doesn't exist on this platform, or for this version
1372
1395
        # of Python.
1394
1417
terminal_width() returns None.
1395
1418
"""
1396
1419
 
 
1420
# Keep some state so that terminal_width can detect if _terminal_size has
 
1421
# returned a different size since the process started.  See docstring and
 
1422
# comments of terminal_width for details.
 
1423
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
 
1424
_terminal_size_state = 'no_data'
 
1425
_first_terminal_size = None
1397
1426
 
1398
1427
def terminal_width():
1399
1428
    """Return terminal width.
1403
1432
    The rules are:
1404
1433
    - if BZR_COLUMNS is set, returns its value
1405
1434
    - if there is no controlling terminal, returns None
 
1435
    - query the OS, if the queried size has changed since the last query,
 
1436
      return its value,
1406
1437
    - if COLUMNS is set, returns its value,
 
1438
    - if the OS has a value (even though it's never changed), return its value.
1407
1439
 
1408
1440
    From there, we need to query the OS to get the size of the controlling
1409
1441
    terminal.
1410
1442
 
1411
 
    Unices:
 
1443
    On Unices we query the OS by:
1412
1444
    - get termios.TIOCGWINSZ
1413
1445
    - if an error occurs or a negative value is obtained, returns None
1414
1446
 
1415
 
    Windows:
1416
 
    
 
1447
    On Windows we query the OS by:
1417
1448
    - win32utils.get_console_size() decides,
1418
1449
    - returns None on error (provided default value)
1419
1450
    """
 
1451
    # Note to implementors: if changing the rules for determining the width,
 
1452
    # make sure you've considered the behaviour in these cases:
 
1453
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
 
1454
    #  - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
 
1455
    #    0,0.
 
1456
    #  - (add more interesting cases here, if you find any)
 
1457
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
 
1458
    # but we don't want to register a signal handler because it is impossible
 
1459
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
 
1460
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
 
1461
    # time so we can notice if the reported size has changed, which should have
 
1462
    # a similar effect.
1420
1463
 
1421
1464
    # If BZR_COLUMNS is set, take it, user is always right
1422
1465
    try:
1425
1468
        pass
1426
1469
 
1427
1470
    isatty = getattr(sys.stdout, 'isatty', None)
1428
 
    if  isatty is None or not isatty():
 
1471
    if isatty is None or not isatty():
1429
1472
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
1430
1473
        return None
1431
1474
 
1432
 
    # If COLUMNS is set, take it, the terminal knows better (even inside a
1433
 
    # given terminal, the application can decide to set COLUMNS to a lower
1434
 
    # value (splitted screen) or a bigger value (scroll bars))
 
1475
    # Query the OS
 
1476
    width, height = os_size = _terminal_size(None, None)
 
1477
    global _first_terminal_size, _terminal_size_state
 
1478
    if _terminal_size_state == 'no_data':
 
1479
        _first_terminal_size = os_size
 
1480
        _terminal_size_state = 'unchanged'
 
1481
    elif (_terminal_size_state == 'unchanged' and
 
1482
          _first_terminal_size != os_size):
 
1483
        _terminal_size_state = 'changed'
 
1484
 
 
1485
    # If the OS claims to know how wide the terminal is, and this value has
 
1486
    # ever changed, use that.
 
1487
    if _terminal_size_state == 'changed':
 
1488
        if width is not None and width > 0:
 
1489
            return width
 
1490
 
 
1491
    # If COLUMNS is set, use it.
1435
1492
    try:
1436
1493
        return int(os.environ['COLUMNS'])
1437
1494
    except (KeyError, ValueError):
1438
1495
        pass
1439
1496
 
1440
 
    width, height = _terminal_size(None, None)
1441
 
    if width <= 0:
1442
 
        # Consider invalid values as meaning no width
1443
 
        return None
 
1497
    # Finally, use an unchanged size from the OS, if we have one.
 
1498
    if _terminal_size_state == 'unchanged':
 
1499
        if width is not None and width > 0:
 
1500
            return width
1444
1501
 
1445
 
    return width
 
1502
    # The width could not be determined.
 
1503
    return None
1446
1504
 
1447
1505
 
1448
1506
def _win32_terminal_size(width, height):
1475
1533
    _terminal_size = _ioctl_terminal_size
1476
1534
 
1477
1535
 
1478
 
def _terminal_size_changed(signum, frame):
1479
 
    """Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
1480
 
    width, height = _terminal_size(None, None)
1481
 
    if width is not None:
1482
 
        os.environ['COLUMNS'] = str(width)
1483
 
 
1484
 
 
1485
 
_registered_sigwinch = False
1486
 
 
1487
 
def watch_sigwinch():
1488
 
    """Register for SIGWINCH, once and only once."""
1489
 
    global _registered_sigwinch
1490
 
    if not _registered_sigwinch:
1491
 
        if sys.platform == 'win32':
1492
 
            # Martin (gz) mentioned WINDOW_BUFFER_SIZE_RECORD from
1493
 
            # ReadConsoleInput but I've no idea how to plug that in
1494
 
            # the current design -- vila 20091216
1495
 
            pass
1496
 
        else:
1497
 
            set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1498
 
        _registered_sigwinch = True
1499
 
 
1500
 
 
1501
1536
def supports_executable():
1502
1537
    return sys.platform != "win32"
1503
1538
 
1626
1661
        dirblock = []
1627
1662
        append = dirblock.append
1628
1663
        try:
1629
 
            names = sorted(_listdir(top))
 
1664
            names = sorted(map(decode_filename, _listdir(top)))
1630
1665
        except OSError, e:
1631
1666
            if not _is_error_enotdir(e):
1632
1667
                raise
1821
1856
            real_handlers[kind](abspath, relpath)
1822
1857
 
1823
1858
 
1824
 
def copy_ownership(dst, src=None):
 
1859
def copy_ownership_from_path(dst, src=None):
1825
1860
    """Copy usr/grp ownership from src file/dir to dst file/dir.
1826
1861
 
1827
1862
    If src is None, the containing directory is used as source. If chown
1843
1878
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1844
1879
 
1845
1880
 
1846
 
def mkdir_with_ownership(path, ownership_src=None):
1847
 
    """Create the directory 'path' with specified ownership.
1848
 
 
1849
 
    If ownership_src is given, copies (chown) usr/grp ownership
1850
 
    from 'ownership_src' to 'path'. If ownership_src is None, use the
1851
 
    containing dir ownership.
1852
 
    """
1853
 
    os.mkdir(path)
1854
 
    copy_ownership(path, ownership_src)
1855
 
 
1856
 
 
1857
 
def open_with_ownership(filename, mode='r', bufsize=-1, ownership_src=None):
1858
 
    """Open the file 'filename' with the specified ownership.
1859
 
 
1860
 
    If ownership_src is specified, copy usr/grp ownership from ownership_src
1861
 
    to filename. If ownership_src is None, copy ownership from containing
1862
 
    directory.
1863
 
    Returns the opened file object.
1864
 
    """
1865
 
    f = open(filename, mode, bufsize)
1866
 
    copy_ownership(filename, ownership_src)
1867
 
    return f
1868
 
 
1869
 
 
1870
1881
def path_prefix_key(path):
1871
1882
    """Generate a prefix-order path key for path.
1872
1883
 
1958
1969
    return user_encoding
1959
1970
 
1960
1971
 
 
1972
def get_diff_header_encoding():
 
1973
    return get_terminal_encoding()
 
1974
 
 
1975
 
1961
1976
def get_host_name():
1962
1977
    """Return the current unicode host name.
1963
1978
 
2026
2041
 
2027
2042
def send_all(sock, bytes, report_activity=None):
2028
2043
    """Send all bytes on a socket.
2029
 
 
 
2044
 
2030
2045
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2031
2046
    some platforms, and catches EINTR which may be thrown if the send is
2032
2047
    interrupted by a signal.
2033
2048
 
2034
2049
    This is preferred to socket.sendall(), because it avoids portability bugs
2035
2050
    and provides activity reporting.
2036
 
 
 
2051
 
2037
2052
    :param report_activity: Call this as bytes are read, see
2038
2053
        Transport._report_activity
2039
2054
    """
2094
2109
    base = dirname(bzrlib.__file__)
2095
2110
    if getattr(sys, 'frozen', None):    # bzr.exe
2096
2111
        base = abspath(pathjoin(base, '..', '..'))
2097
 
    filename = pathjoin(base, resource_relpath)
2098
 
    return open(filename, 'rU').read()
2099
 
 
 
2112
    f = file(pathjoin(base, resource_relpath), "rU")
 
2113
    try:
 
2114
        return f.read()
 
2115
    finally:
 
2116
        f.close()
2100
2117
 
2101
2118
def file_kind_from_stat_mode_thunk(mode):
2102
2119
    global file_kind_from_stat_mode
2125
2142
 
2126
2143
def until_no_eintr(f, *a, **kw):
2127
2144
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2128
 
    
 
2145
 
2129
2146
    WARNING: you must be certain that it is safe to retry the call repeatedly
2130
2147
    if EINTR does occur.  This is typically only true for low-level operations
2131
2148
    like os.read.  If in any doubt, don't use this.
2146
2163
            raise
2147
2164
 
2148
2165
 
 
2166
@deprecated_function(deprecated_in((2, 2, 0)))
2149
2167
def re_compile_checked(re_string, flags=0, where=""):
2150
2168
    """Return a compiled re, or raise a sensible error.
2151
2169
 
2161
2179
        re_obj = re.compile(re_string, flags)
2162
2180
        re_obj.search("")
2163
2181
        return re_obj
2164
 
    except re.error, e:
 
2182
    except errors.InvalidPattern, e:
2165
2183
        if where:
2166
2184
            where = ' in ' + where
2167
2185
        # despite the name 'error' is a type
2168
 
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
2169
 
            % (where, re_string, e))
 
2186
        raise errors.BzrCommandError('Invalid regular expression%s: %s'
 
2187
            % (where, e.msg))
2170
2188
 
2171
2189
 
2172
2190
if sys.platform == "win32":
2262
2280
if sys.platform == 'win32':
2263
2281
    def open_file(filename, mode='r', bufsize=-1):
2264
2282
        """This function is used to override the ``open`` builtin.
2265
 
        
 
2283
 
2266
2284
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2267
2285
        child processes.  Deleting or renaming a closed file opened with this
2268
2286
        function is not blocking child processes.
2301
2319
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2302
2320
else:
2303
2321
    open_file = open
 
2322
 
 
2323
 
 
2324
def getuser_unicode():
 
2325
    """Return the username as unicode.
 
2326
    """
 
2327
    try:
 
2328
        user_encoding = get_user_encoding()
 
2329
        username = getpass.getuser().decode(user_encoding)
 
2330
    except UnicodeDecodeError:
 
2331
        raise errors.BzrError("Can't decode username as %s." % \
 
2332
                user_encoding)
 
2333
    return username