/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
18
17
import os
19
18
import re
20
19
import stat
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
21
import sys
22
22
import time
23
23
import codecs
25
25
from bzrlib.lazy_import import lazy_import
26
26
lazy_import(globals(), """
27
27
from datetime import datetime
28
 
import getpass
29
 
import ntpath
 
28
import errno
 
29
from ntpath import (abspath as _nt_abspath,
 
30
                    join as _nt_join,
 
31
                    normpath as _nt_normpath,
 
32
                    realpath as _nt_realpath,
 
33
                    splitdrive as _nt_splitdrive,
 
34
                    )
30
35
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
33
36
import shutil
34
 
from shutil import rmtree
 
37
from shutil import (
 
38
    rmtree,
 
39
    )
35
40
import socket
36
41
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
39
42
import tempfile
40
 
from tempfile import mkdtemp
 
43
from tempfile import (
 
44
    mkdtemp,
 
45
    )
41
46
import unicodedata
42
47
 
43
48
from bzrlib import (
298
303
    running python.exe under cmd.exe return capital C:\\
299
304
    running win32 python inside a cygwin shell returns lowercase c:\\
300
305
    """
301
 
    drive, path = ntpath.splitdrive(path)
 
306
    drive, path = _nt_splitdrive(path)
302
307
    return drive.upper() + path
303
308
 
304
309
 
305
310
def _win32_abspath(path):
306
 
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
307
 
    return _win32_fixdrive(ntpath.abspath(unicode(path)).replace('\\', '/'))
 
311
    # Real _nt_abspath doesn't have a problem with a unicode cwd
 
312
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
308
313
 
309
314
 
310
315
def _win98_abspath(path):
321
326
    #   /path       => C:/path
322
327
    path = unicode(path)
323
328
    # check for absolute path
324
 
    drive = ntpath.splitdrive(path)[0]
 
329
    drive = _nt_splitdrive(path)[0]
325
330
    if drive == '' and path[:2] not in('//','\\\\'):
326
331
        cwd = os.getcwdu()
327
332
        # we cannot simply os.path.join cwd and path
328
333
        # because os.path.join('C:','/path') produce '/path'
329
334
        # and this is incorrect
330
335
        if path[:1] in ('/','\\'):
331
 
            cwd = ntpath.splitdrive(cwd)[0]
 
336
            cwd = _nt_splitdrive(cwd)[0]
332
337
            path = path[1:]
333
338
        path = cwd + '\\' + path
334
 
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
 
339
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
335
340
 
336
341
 
337
342
def _win32_realpath(path):
338
 
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
339
 
    return _win32_fixdrive(ntpath.realpath(unicode(path)).replace('\\', '/'))
 
343
    # Real _nt_realpath doesn't have a problem with a unicode cwd
 
344
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
340
345
 
341
346
 
342
347
def _win32_pathjoin(*args):
343
 
    return ntpath.join(*args).replace('\\', '/')
 
348
    return _nt_join(*args).replace('\\', '/')
344
349
 
345
350
 
346
351
def _win32_normpath(path):
347
 
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
 
352
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
348
353
 
349
354
 
350
355
def _win32_getcwd():
355
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
356
361
 
357
362
 
 
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
 
358
371
def _win32_rename(old, new):
359
372
    """We expect to be able to atomically replace 'new' with old.
360
373
 
362
375
    and then deleted.
363
376
    """
364
377
    try:
365
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
378
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
366
379
    except OSError, e:
367
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
368
381
            # If we try to rename a non-existant file onto cwd, we get
373
386
        raise
374
387
 
375
388
 
 
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
 
376
399
def _mac_getcwd():
377
400
    return unicodedata.normalize('NFC', os.getcwdu())
378
401
 
383
406
realpath = _posix_realpath
384
407
pathjoin = os.path.join
385
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
386
410
getcwd = os.getcwdu
387
 
rename = os.rename
388
411
dirname = os.path.dirname
389
412
basename = os.path.basename
390
413
split = os.path.split
391
414
splitext = os.path.splitext
392
 
# These were already lazily imported into local scope
 
415
# These were already imported into local scope
393
416
# mkdtemp = tempfile.mkdtemp
394
417
# rmtree = shutil.rmtree
395
418
 
435
458
    getcwd = _mac_getcwd
436
459
 
437
460
 
438
 
def get_terminal_encoding(trace=False):
 
461
def get_terminal_encoding():
439
462
    """Find the best encoding for printing to the screen.
440
463
 
441
464
    This attempts to check both sys.stdout and sys.stdin to see
447
470
 
448
471
    On my standard US Windows XP, the preferred encoding is
449
472
    cp1252, but the console is cp437
450
 
 
451
 
    :param trace: If True trace the selected encoding via mutter().
452
473
    """
453
474
    from bzrlib.trace import mutter
454
475
    output_encoding = getattr(sys.stdout, 'encoding', None)
456
477
        input_encoding = getattr(sys.stdin, 'encoding', None)
457
478
        if not input_encoding:
458
479
            output_encoding = get_user_encoding()
459
 
            if trace:
460
 
                mutter('encoding stdout as osutils.get_user_encoding() %r',
 
480
            mutter('encoding stdout as osutils.get_user_encoding() %r',
461
481
                   output_encoding)
462
482
        else:
463
483
            output_encoding = input_encoding
464
 
            if trace:
465
 
                mutter('encoding stdout as sys.stdin encoding %r',
466
 
                    output_encoding)
 
484
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
467
485
    else:
468
 
        if trace:
469
 
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
486
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
470
487
    if output_encoding == 'cp0':
471
488
        # invalid encoding (cp0 means 'no codepage' on Windows)
472
489
        output_encoding = get_user_encoding()
473
 
        if trace:
474
 
            mutter('cp0 is invalid encoding.'
 
490
        mutter('cp0 is invalid encoding.'
475
491
               ' encoding stdout as osutils.get_user_encoding() %r',
476
492
               output_encoding)
477
493
    # check encoding
503
519
def isdir(f):
504
520
    """True if f is an accessible directory."""
505
521
    try:
506
 
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
 
522
        return S_ISDIR(os.lstat(f)[ST_MODE])
507
523
    except OSError:
508
524
        return False
509
525
 
511
527
def isfile(f):
512
528
    """True if f is a regular file."""
513
529
    try:
514
 
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
 
530
        return S_ISREG(os.lstat(f)[ST_MODE])
515
531
    except OSError:
516
532
        return False
517
533
 
518
534
def islink(f):
519
535
    """True if f is a symlink."""
520
536
    try:
521
 
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
 
537
        return S_ISLNK(os.lstat(f)[ST_MODE])
522
538
    except OSError:
523
539
        return False
524
540
 
864
880
 
865
881
def filesize(f):
866
882
    """Return size of given open file."""
867
 
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
883
    return os.fstat(f.fileno())[ST_SIZE]
868
884
 
869
885
 
870
886
# Define rand_bytes based on platform.
932
948
 
933
949
def parent_directories(filename):
934
950
    """Return the list of parent directories, deepest first.
935
 
 
 
951
    
936
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
937
953
    """
938
954
    parents = []
962
978
    # NB: This docstring is just an example, not a doctest, because doctest
963
979
    # currently can't cope with the use of lazy imports in this namespace --
964
980
    # mbp 20090729
965
 
 
 
981
    
966
982
    # This currently doesn't report the failure at the time it occurs, because
967
983
    # they tend to happen very early in startup when we can't check config
968
984
    # files etc, and also we want to report all failures but not spam the user
969
985
    # with 10 warnings.
 
986
    from bzrlib import trace
970
987
    exception_str = str(exception)
971
988
    if exception_str not in _extension_load_failures:
972
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
1037
1054
 
1038
1055
 
1039
1056
def delete_any(path):
1040
 
    """Delete a file, symlink or directory.
1041
 
 
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
1042
1059
    Will delete even if readonly.
1043
1060
    """
1044
1061
    try:
1233
1250
    # but for now, we haven't optimized...
1234
1251
    return [canonical_relpath(base, p) for p in paths]
1235
1252
 
1236
 
 
1237
 
def decode_filename(filename):
1238
 
    """Decode the filename using the filesystem encoding
1239
 
 
1240
 
    If it is unicode, it is returned.
1241
 
    Otherwise it is decoded from the the filesystem's encoding. If decoding
1242
 
    fails, a errors.BadFilenameEncoding exception is raised.
1243
 
    """
1244
 
    if type(filename) is unicode:
1245
 
        return filename
1246
 
    try:
1247
 
        return filename.decode(_fs_enc)
1248
 
    except UnicodeDecodeError:
1249
 
        raise errors.BadFilenameEncoding(filename, _fs_enc)
1250
 
 
1251
 
 
1252
1253
def safe_unicode(unicode_or_utf8_string):
1253
1254
    """Coerce unicode_or_utf8_string into unicode.
1254
1255
 
1337
1338
def normalizes_filenames():
1338
1339
    """Return True if this platform normalizes unicode filenames.
1339
1340
 
1340
 
    Only Mac OSX.
 
1341
    Mac OSX does, Windows/Linux do not.
1341
1342
    """
1342
1343
    return _platform_normalizes_filenames
1343
1344
 
1348
1349
    On platforms where the system normalizes filenames (Mac OSX),
1349
1350
    you can access a file by any path which will normalize correctly.
1350
1351
    On platforms where the system does not normalize filenames
1351
 
    (everything else), you have to access a file by its exact path.
 
1352
    (Windows, Linux), you have to access a file by its exact path.
1352
1353
 
1353
1354
    Internally, bzr only supports NFC normalization, since that is
1354
1355
    the standard for XML documents.
1416
1417
terminal_width() returns None.
1417
1418
"""
1418
1419
 
1419
 
# Keep some state so that terminal_width can detect if _terminal_size has
1420
 
# returned a different size since the process started.  See docstring and
1421
 
# comments of terminal_width for details.
1422
 
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1423
 
_terminal_size_state = 'no_data'
1424
 
_first_terminal_size = None
1425
1420
 
1426
1421
def terminal_width():
1427
1422
    """Return terminal width.
1431
1426
    The rules are:
1432
1427
    - if BZR_COLUMNS is set, returns its value
1433
1428
    - if there is no controlling terminal, returns None
1434
 
    - query the OS, if the queried size has changed since the last query,
1435
 
      return its value,
1436
1429
    - if COLUMNS is set, returns its value,
1437
 
    - if the OS has a value (even though it's never changed), return its value.
1438
1430
 
1439
1431
    From there, we need to query the OS to get the size of the controlling
1440
1432
    terminal.
1441
1433
 
1442
 
    On Unices we query the OS by:
 
1434
    Unices:
1443
1435
    - get termios.TIOCGWINSZ
1444
1436
    - if an error occurs or a negative value is obtained, returns None
1445
1437
 
1446
 
    On Windows we query the OS by:
 
1438
    Windows:
 
1439
    
1447
1440
    - win32utils.get_console_size() decides,
1448
1441
    - returns None on error (provided default value)
1449
1442
    """
1450
 
    # Note to implementors: if changing the rules for determining the width,
1451
 
    # make sure you've considered the behaviour in these cases:
1452
 
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1453
 
    #  - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1454
 
    #    0,0.
1455
 
    #  - (add more interesting cases here, if you find any)
1456
 
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1457
 
    # but we don't want to register a signal handler because it is impossible
1458
 
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
1459
 
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
1460
 
    # time so we can notice if the reported size has changed, which should have
1461
 
    # a similar effect.
1462
1443
 
1463
1444
    # If BZR_COLUMNS is set, take it, user is always right
1464
 
    # Except if they specified 0 in which case, impose no limit here
1465
1445
    try:
1466
 
        width = int(os.environ['BZR_COLUMNS'])
 
1446
        return int(os.environ['BZR_COLUMNS'])
1467
1447
    except (KeyError, ValueError):
1468
 
        width = None
1469
 
    if width is not None:
1470
 
        if width > 0:
1471
 
            return width
1472
 
        else:
1473
 
            return None
 
1448
        pass
1474
1449
 
1475
1450
    isatty = getattr(sys.stdout, 'isatty', None)
1476
 
    if isatty is None or not isatty():
 
1451
    if  isatty is None or not isatty():
1477
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
1478
1453
        return None
1479
1454
 
1480
 
    # Query the OS
1481
 
    width, height = os_size = _terminal_size(None, None)
1482
 
    global _first_terminal_size, _terminal_size_state
1483
 
    if _terminal_size_state == 'no_data':
1484
 
        _first_terminal_size = os_size
1485
 
        _terminal_size_state = 'unchanged'
1486
 
    elif (_terminal_size_state == 'unchanged' and
1487
 
          _first_terminal_size != os_size):
1488
 
        _terminal_size_state = 'changed'
1489
 
 
1490
 
    # If the OS claims to know how wide the terminal is, and this value has
1491
 
    # ever changed, use that.
1492
 
    if _terminal_size_state == 'changed':
1493
 
        if width is not None and width > 0:
1494
 
            return width
1495
 
 
1496
 
    # If COLUMNS is set, use it.
 
1455
    # If COLUMNS is set, take it, the terminal knows better (even inside a
 
1456
    # given terminal, the application can decide to set COLUMNS to a lower
 
1457
    # value (splitted screen) or a bigger value (scroll bars))
1497
1458
    try:
1498
1459
        return int(os.environ['COLUMNS'])
1499
1460
    except (KeyError, ValueError):
1500
1461
        pass
1501
1462
 
1502
 
    # Finally, use an unchanged size from the OS, if we have one.
1503
 
    if _terminal_size_state == 'unchanged':
1504
 
        if width is not None and width > 0:
1505
 
            return width
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
1506
1467
 
1507
 
    # The width could not be determined.
1508
 
    return None
 
1468
    return width
1509
1469
 
1510
1470
 
1511
1471
def _win32_terminal_size(width, height):
1538
1498
    _terminal_size = _ioctl_terminal_size
1539
1499
 
1540
1500
 
 
1501
def _terminal_size_changed(signum, frame):
 
1502
    """Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
 
1503
    width, height = _terminal_size(None, None)
 
1504
    if width is not None:
 
1505
        os.environ['COLUMNS'] = str(width)
 
1506
 
 
1507
 
 
1508
_registered_sigwinch = False
 
1509
def watch_sigwinch():
 
1510
    """Register for SIGWINCH, once and only once.
 
1511
 
 
1512
    Do nothing if the signal module is not available.
 
1513
    """
 
1514
    global _registered_sigwinch
 
1515
    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
 
1522
            pass
 
1523
        _registered_sigwinch = True
 
1524
 
 
1525
 
1541
1526
def supports_executable():
1542
1527
    return sys.platform != "win32"
1543
1528
 
1666
1651
        dirblock = []
1667
1652
        append = dirblock.append
1668
1653
        try:
1669
 
            names = sorted(map(decode_filename, _listdir(top)))
 
1654
            names = sorted(_listdir(top))
1670
1655
        except OSError, e:
1671
1656
            if not _is_error_enotdir(e):
1672
1657
                raise
1880
1865
        s = os.stat(src)
1881
1866
        chown(dst, s.st_uid, s.st_gid)
1882
1867
    except OSError, e:
1883
 
        trace.warning(
1884
 
            'Unable to copy ownership from "%s" to "%s". '
1885
 
            'You may want to set it manually.', src, dst)
1886
 
        trace.log_exception_quietly()
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1887
1869
 
1888
1870
 
1889
1871
def path_prefix_key(path):
1977
1959
    return user_encoding
1978
1960
 
1979
1961
 
1980
 
def get_diff_header_encoding():
1981
 
    return get_terminal_encoding()
1982
 
 
1983
 
 
1984
1962
def get_host_name():
1985
1963
    """Return the current unicode host name.
1986
1964
 
2001
1979
# data at once.
2002
1980
MAX_SOCKET_CHUNK = 64 * 1024
2003
1981
 
2004
 
_end_of_stream_errors = [errno.ECONNRESET]
2005
 
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2006
 
    _eno = getattr(errno, _eno, None)
2007
 
    if _eno is not None:
2008
 
        _end_of_stream_errors.append(_eno)
2009
 
del _eno
2010
 
 
2011
 
 
2012
1982
def read_bytes_from_socket(sock, report_activity=None,
2013
1983
        max_read_size=MAX_SOCKET_CHUNK):
2014
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
2022
1992
            bytes = sock.recv(max_read_size)
2023
1993
        except socket.error, e:
2024
1994
            eno = e.args[0]
2025
 
            if eno in _end_of_stream_errors:
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
2026
1996
                # The connection was closed by the other side.  Callers expect
2027
1997
                # an empty string to signal end-of-stream.
2028
1998
                return ""
2057
2027
 
2058
2028
def send_all(sock, bytes, report_activity=None):
2059
2029
    """Send all bytes on a socket.
2060
 
 
 
2030
 
2061
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2062
2032
    some platforms, and catches EINTR which may be thrown if the send is
2063
2033
    interrupted by a signal.
2064
2034
 
2065
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
2066
2036
    and provides activity reporting.
2067
 
 
 
2037
 
2068
2038
    :param report_activity: Call this as bytes are read, see
2069
2039
        Transport._report_activity
2070
2040
    """
2081
2051
            report_activity(sent, 'write')
2082
2052
 
2083
2053
 
2084
 
def connect_socket(address):
2085
 
    # Slight variation of the socket.create_connection() function (provided by
2086
 
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
2087
 
    # provide it for previous python versions. Also, we don't use the timeout
2088
 
    # parameter (provided by the python implementation) so we don't implement
2089
 
    # it either).
2090
 
    err = socket.error('getaddrinfo returns an empty list')
2091
 
    host, port = address
2092
 
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
2093
 
        af, socktype, proto, canonname, sa = res
2094
 
        sock = None
2095
 
        try:
2096
 
            sock = socket.socket(af, socktype, proto)
2097
 
            sock.connect(sa)
2098
 
            return sock
2099
 
 
2100
 
        except socket.error, err:
2101
 
            # 'err' is now the most recent error
2102
 
            if sock is not None:
2103
 
                sock.close()
2104
 
    raise err
2105
 
 
2106
 
 
2107
2054
def dereference_path(path):
2108
2055
    """Determine the real path to a file.
2109
2056
 
2148
2095
    base = dirname(bzrlib.__file__)
2149
2096
    if getattr(sys, 'frozen', None):    # bzr.exe
2150
2097
        base = abspath(pathjoin(base, '..', '..'))
2151
 
    f = file(pathjoin(base, resource_relpath), "rU")
2152
 
    try:
2153
 
        return f.read()
2154
 
    finally:
2155
 
        f.close()
 
2098
    filename = pathjoin(base, resource_relpath)
 
2099
    return open(filename, 'rU').read()
 
2100
 
2156
2101
 
2157
2102
def file_kind_from_stat_mode_thunk(mode):
2158
2103
    global file_kind_from_stat_mode
2181
2126
 
2182
2127
def until_no_eintr(f, *a, **kw):
2183
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2184
 
 
 
2129
    
2185
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
2186
2131
    if EINTR does occur.  This is typically only true for low-level operations
2187
2132
    like os.read.  If in any doubt, don't use this.
2202
2147
            raise
2203
2148
 
2204
2149
 
2205
 
@deprecated_function(deprecated_in((2, 2, 0)))
2206
2150
def re_compile_checked(re_string, flags=0, where=""):
2207
2151
    """Return a compiled re, or raise a sensible error.
2208
2152
 
2218
2162
        re_obj = re.compile(re_string, flags)
2219
2163
        re_obj.search("")
2220
2164
        return re_obj
2221
 
    except errors.InvalidPattern, e:
 
2165
    except re.error, e:
2222
2166
        if where:
2223
2167
            where = ' in ' + where
2224
2168
        # despite the name 'error' is a type
2225
 
        raise errors.BzrCommandError('Invalid regular expression%s: %s'
2226
 
            % (where, e.msg))
 
2169
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
2170
            % (where, re_string, e))
2227
2171
 
2228
2172
 
2229
2173
if sys.platform == "win32":
2319
2263
if sys.platform == 'win32':
2320
2264
    def open_file(filename, mode='r', bufsize=-1):
2321
2265
        """This function is used to override the ``open`` builtin.
2322
 
 
 
2266
        
2323
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2324
2268
        child processes.  Deleting or renaming a closed file opened with this
2325
2269
        function is not blocking child processes.
2358
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2359
2303
else:
2360
2304
    open_file = open
2361
 
 
2362
 
 
2363
 
def getuser_unicode():
2364
 
    """Return the username as unicode.
2365
 
    """
2366
 
    try:
2367
 
        user_encoding = get_user_encoding()
2368
 
        username = getpass.getuser().decode(user_encoding)
2369
 
    except UnicodeDecodeError:
2370
 
        raise errors.BzrError("Can't decode username as %s." % \
2371
 
                user_encoding)
2372
 
    return username
2373
 
 
2374
 
 
2375
 
def available_backup_name(base, exists):
2376
 
    """Find a non-existing backup file name.
2377
 
 
2378
 
    This will *not* create anything, this only return a 'free' entry.  This
2379
 
    should be used for checking names in a directory below a locked
2380
 
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
2381
 
    Leap) and generally discouraged.
2382
 
 
2383
 
    :param base: The base name.
2384
 
 
2385
 
    :param exists: A callable returning True if the path parameter exists.
2386
 
    """
2387
 
    counter = 1
2388
 
    name = "%s.~%d~" % (base, counter)
2389
 
    while exists(name):
2390
 
        counter += 1
2391
 
        name = "%s.~%d~" % (base, counter)
2392
 
    return name
2393
 
 
2394
 
 
2395
 
def set_fd_cloexec(fd):
2396
 
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
2397
 
    support for this is not available.
2398
 
    """
2399
 
    try:
2400
 
        import fcntl
2401
 
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
2402
 
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
2403
 
    except (ImportError, AttributeError):
2404
 
        # Either the fcntl module or specific constants are not present
2405
 
        pass