← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2010-05-11 08:36:16 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100511083616-b8fjb19zomwupid0
Make all lock methods return Result objects, rather than lock_read returning self, as per John's review.

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 (
53
58
    deprecated_in,
54
59
    )
55
60
 
56
 
from hashlib import (
57
 
    md5,
58
 
    sha1 as sha,
59
 
    )
 
61
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
 
62
# of 2.5
 
63
if sys.version_info < (2, 5):
 
64
    import md5 as _mod_md5
 
65
    md5 = _mod_md5.new
 
66
    import sha as _mod_sha
 
67
    sha = _mod_sha.new
 
68
else:
 
69
    from hashlib import (
 
70
        md5,
 
71
        sha1 as sha,
 
72
        )
60
73
 
61
74
 
62
75
import bzrlib
88
101
        user_encoding = get_user_encoding()
89
102
        return [a.decode(user_encoding) for a in sys.argv[1:]]
90
103
    except UnicodeDecodeError:
91
 
        raise errors.BzrError("Parameter %r encoding is unsupported by %s "
92
 
            "application locale." % (a, user_encoding))
 
104
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
105
                                                            "encoding." % a))
93
106
 
94
107
 
95
108
def make_readonly(filename):
261
274
            else:
262
275
                rename_func(tmp_name, new)
263
276
    if failure_exc is not None:
264
 
        try:
265
 
            raise failure_exc[0], failure_exc[1], failure_exc[2]
266
 
        finally:
267
 
            del failure_exc
 
277
        raise failure_exc[0], failure_exc[1], failure_exc[2]
268
278
 
269
279
 
270
280
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
293
303
    running python.exe under cmd.exe return capital C:\\
294
304
    running win32 python inside a cygwin shell returns lowercase c:\\
295
305
    """
296
 
    drive, path = ntpath.splitdrive(path)
 
306
    drive, path = _nt_splitdrive(path)
297
307
    return drive.upper() + path
298
308
 
299
309
 
300
310
def _win32_abspath(path):
301
 
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
302
 
    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('\\', '/'))
303
313
 
304
314
 
305
315
def _win98_abspath(path):
316
326
    #   /path       => C:/path
317
327
    path = unicode(path)
318
328
    # check for absolute path
319
 
    drive = ntpath.splitdrive(path)[0]
 
329
    drive = _nt_splitdrive(path)[0]
320
330
    if drive == '' and path[:2] not in('//','\\\\'):
321
331
        cwd = os.getcwdu()
322
332
        # we cannot simply os.path.join cwd and path
323
333
        # because os.path.join('C:','/path') produce '/path'
324
334
        # and this is incorrect
325
335
        if path[:1] in ('/','\\'):
326
 
            cwd = ntpath.splitdrive(cwd)[0]
 
336
            cwd = _nt_splitdrive(cwd)[0]
327
337
            path = path[1:]
328
338
        path = cwd + '\\' + path
329
 
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
 
339
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
330
340
 
331
341
 
332
342
def _win32_realpath(path):
333
 
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
334
 
    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('\\', '/'))
335
345
 
336
346
 
337
347
def _win32_pathjoin(*args):
338
 
    return ntpath.join(*args).replace('\\', '/')
 
348
    return _nt_join(*args).replace('\\', '/')
339
349
 
340
350
 
341
351
def _win32_normpath(path):
342
 
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
 
352
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
343
353
 
344
354
 
345
355
def _win32_getcwd():
350
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
351
361
 
352
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
 
353
371
def _win32_rename(old, new):
354
372
    """We expect to be able to atomically replace 'new' with old.
355
373
 
357
375
    and then deleted.
358
376
    """
359
377
    try:
360
 
        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)
361
379
    except OSError, e:
362
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
363
381
            # If we try to rename a non-existant file onto cwd, we get
368
386
        raise
369
387
 
370
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
 
371
399
def _mac_getcwd():
372
400
    return unicodedata.normalize('NFC', os.getcwdu())
373
401
 
378
406
realpath = _posix_realpath
379
407
pathjoin = os.path.join
380
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
381
410
getcwd = os.getcwdu
382
 
rename = os.rename
383
411
dirname = os.path.dirname
384
412
basename = os.path.basename
385
413
split = os.path.split
386
414
splitext = os.path.splitext
387
 
# These were already lazily imported into local scope
 
415
# These were already imported into local scope
388
416
# mkdtemp = tempfile.mkdtemp
389
417
# rmtree = shutil.rmtree
390
 
lstat = os.lstat
391
 
fstat = os.fstat
392
 
 
393
 
def wrap_stat(st):
394
 
    return st
395
 
 
396
418
 
397
419
MIN_ABS_PATHLENGTH = 1
398
420
 
408
430
    getcwd = _win32_getcwd
409
431
    mkdtemp = _win32_mkdtemp
410
432
    rename = _win32_rename
411
 
    try:
412
 
        from bzrlib import _walkdirs_win32
413
 
    except ImportError:
414
 
        pass
415
 
    else:
416
 
        lstat = _walkdirs_win32.lstat
417
 
        fstat = _walkdirs_win32.fstat
418
 
        wrap_stat = _walkdirs_win32.wrap_stat
419
433
 
420
434
    MIN_ABS_PATHLENGTH = 3
421
435
 
444
458
    getcwd = _mac_getcwd
445
459
 
446
460
 
447
 
def get_terminal_encoding(trace=False):
 
461
def get_terminal_encoding():
448
462
    """Find the best encoding for printing to the screen.
449
463
 
450
464
    This attempts to check both sys.stdout and sys.stdin to see
456
470
 
457
471
    On my standard US Windows XP, the preferred encoding is
458
472
    cp1252, but the console is cp437
459
 
 
460
 
    :param trace: If True trace the selected encoding via mutter().
461
473
    """
462
474
    from bzrlib.trace import mutter
463
475
    output_encoding = getattr(sys.stdout, 'encoding', None)
465
477
        input_encoding = getattr(sys.stdin, 'encoding', None)
466
478
        if not input_encoding:
467
479
            output_encoding = get_user_encoding()
468
 
            if trace:
469
 
                mutter('encoding stdout as osutils.get_user_encoding() %r',
 
480
            mutter('encoding stdout as osutils.get_user_encoding() %r',
470
481
                   output_encoding)
471
482
        else:
472
483
            output_encoding = input_encoding
473
 
            if trace:
474
 
                mutter('encoding stdout as sys.stdin encoding %r',
475
 
                    output_encoding)
 
484
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
476
485
    else:
477
 
        if trace:
478
 
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
486
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
479
487
    if output_encoding == 'cp0':
480
488
        # invalid encoding (cp0 means 'no codepage' on Windows)
481
489
        output_encoding = get_user_encoding()
482
 
        if trace:
483
 
            mutter('cp0 is invalid encoding.'
 
490
        mutter('cp0 is invalid encoding.'
484
491
               ' encoding stdout as osutils.get_user_encoding() %r',
485
492
               output_encoding)
486
493
    # check encoding
512
519
def isdir(f):
513
520
    """True if f is an accessible directory."""
514
521
    try:
515
 
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
 
522
        return S_ISDIR(os.lstat(f)[ST_MODE])
516
523
    except OSError:
517
524
        return False
518
525
 
520
527
def isfile(f):
521
528
    """True if f is a regular file."""
522
529
    try:
523
 
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
 
530
        return S_ISREG(os.lstat(f)[ST_MODE])
524
531
    except OSError:
525
532
        return False
526
533
 
527
534
def islink(f):
528
535
    """True if f is a symlink."""
529
536
    try:
530
 
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
 
537
        return S_ISLNK(os.lstat(f)[ST_MODE])
531
538
    except OSError:
532
539
        return False
533
540
 
873
880
 
874
881
def filesize(f):
875
882
    """Return size of given open file."""
876
 
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
883
    return os.fstat(f.fileno())[ST_SIZE]
877
884
 
878
885
 
879
886
# Define rand_bytes based on platform.
941
948
 
942
949
def parent_directories(filename):
943
950
    """Return the list of parent directories, deepest first.
944
 
 
 
951
    
945
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
946
953
    """
947
954
    parents = []
971
978
    # NB: This docstring is just an example, not a doctest, because doctest
972
979
    # currently can't cope with the use of lazy imports in this namespace --
973
980
    # mbp 20090729
974
 
 
 
981
    
975
982
    # This currently doesn't report the failure at the time it occurs, because
976
983
    # they tend to happen very early in startup when we can't check config
977
984
    # files etc, and also we want to report all failures but not spam the user
978
985
    # with 10 warnings.
 
986
    from bzrlib import trace
979
987
    exception_str = str(exception)
980
988
    if exception_str not in _extension_load_failures:
981
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
1046
1054
 
1047
1055
 
1048
1056
def delete_any(path):
1049
 
    """Delete a file, symlink or directory.
1050
 
 
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
1051
1059
    Will delete even if readonly.
1052
1060
    """
1053
1061
    try:
1242
1250
    # but for now, we haven't optimized...
1243
1251
    return [canonical_relpath(base, p) for p in paths]
1244
1252
 
1245
 
 
1246
 
def decode_filename(filename):
1247
 
    """Decode the filename using the filesystem encoding
1248
 
 
1249
 
    If it is unicode, it is returned.
1250
 
    Otherwise it is decoded from the the filesystem's encoding. If decoding
1251
 
    fails, a errors.BadFilenameEncoding exception is raised.
1252
 
    """
1253
 
    if type(filename) is unicode:
1254
 
        return filename
1255
 
    try:
1256
 
        return filename.decode(_fs_enc)
1257
 
    except UnicodeDecodeError:
1258
 
        raise errors.BadFilenameEncoding(filename, _fs_enc)
1259
 
 
1260
 
 
1261
1253
def safe_unicode(unicode_or_utf8_string):
1262
1254
    """Coerce unicode_or_utf8_string into unicode.
1263
1255
 
1346
1338
def normalizes_filenames():
1347
1339
    """Return True if this platform normalizes unicode filenames.
1348
1340
 
1349
 
    Only Mac OSX.
 
1341
    Mac OSX does, Windows/Linux do not.
1350
1342
    """
1351
1343
    return _platform_normalizes_filenames
1352
1344
 
1357
1349
    On platforms where the system normalizes filenames (Mac OSX),
1358
1350
    you can access a file by any path which will normalize correctly.
1359
1351
    On platforms where the system does not normalize filenames
1360
 
    (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.
1361
1353
 
1362
1354
    Internally, bzr only supports NFC normalization, since that is
1363
1355
    the standard for XML documents.
1425
1417
terminal_width() returns None.
1426
1418
"""
1427
1419
 
1428
 
# Keep some state so that terminal_width can detect if _terminal_size has
1429
 
# returned a different size since the process started.  See docstring and
1430
 
# comments of terminal_width for details.
1431
 
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1432
 
_terminal_size_state = 'no_data'
1433
 
_first_terminal_size = None
1434
1420
 
1435
1421
def terminal_width():
1436
1422
    """Return terminal width.
1440
1426
    The rules are:
1441
1427
    - if BZR_COLUMNS is set, returns its value
1442
1428
    - if there is no controlling terminal, returns None
1443
 
    - query the OS, if the queried size has changed since the last query,
1444
 
      return its value,
1445
1429
    - if COLUMNS is set, returns its value,
1446
 
    - if the OS has a value (even though it's never changed), return its value.
1447
1430
 
1448
1431
    From there, we need to query the OS to get the size of the controlling
1449
1432
    terminal.
1450
1433
 
1451
 
    On Unices we query the OS by:
 
1434
    Unices:
1452
1435
    - get termios.TIOCGWINSZ
1453
1436
    - if an error occurs or a negative value is obtained, returns None
1454
1437
 
1455
 
    On Windows we query the OS by:
 
1438
    Windows:
 
1439
    
1456
1440
    - win32utils.get_console_size() decides,
1457
1441
    - returns None on error (provided default value)
1458
1442
    """
1459
 
    # Note to implementors: if changing the rules for determining the width,
1460
 
    # make sure you've considered the behaviour in these cases:
1461
 
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1462
 
    #  - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1463
 
    #    0,0.
1464
 
    #  - (add more interesting cases here, if you find any)
1465
 
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1466
 
    # but we don't want to register a signal handler because it is impossible
1467
 
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
1468
 
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
1469
 
    # time so we can notice if the reported size has changed, which should have
1470
 
    # a similar effect.
1471
1443
 
1472
1444
    # If BZR_COLUMNS is set, take it, user is always right
1473
 
    # Except if they specified 0 in which case, impose no limit here
1474
1445
    try:
1475
 
        width = int(os.environ['BZR_COLUMNS'])
 
1446
        return int(os.environ['BZR_COLUMNS'])
1476
1447
    except (KeyError, ValueError):
1477
 
        width = None
1478
 
    if width is not None:
1479
 
        if width > 0:
1480
 
            return width
1481
 
        else:
1482
 
            return None
 
1448
        pass
1483
1449
 
1484
1450
    isatty = getattr(sys.stdout, 'isatty', None)
1485
 
    if isatty is None or not isatty():
 
1451
    if  isatty is None or not isatty():
1486
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
1487
1453
        return None
1488
1454
 
1489
 
    # Query the OS
1490
 
    width, height = os_size = _terminal_size(None, None)
1491
 
    global _first_terminal_size, _terminal_size_state
1492
 
    if _terminal_size_state == 'no_data':
1493
 
        _first_terminal_size = os_size
1494
 
        _terminal_size_state = 'unchanged'
1495
 
    elif (_terminal_size_state == 'unchanged' and
1496
 
          _first_terminal_size != os_size):
1497
 
        _terminal_size_state = 'changed'
1498
 
 
1499
 
    # If the OS claims to know how wide the terminal is, and this value has
1500
 
    # ever changed, use that.
1501
 
    if _terminal_size_state == 'changed':
1502
 
        if width is not None and width > 0:
1503
 
            return width
1504
 
 
1505
 
    # 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))
1506
1458
    try:
1507
1459
        return int(os.environ['COLUMNS'])
1508
1460
    except (KeyError, ValueError):
1509
1461
        pass
1510
1462
 
1511
 
    # Finally, use an unchanged size from the OS, if we have one.
1512
 
    if _terminal_size_state == 'unchanged':
1513
 
        if width is not None and width > 0:
1514
 
            return width
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
1515
1467
 
1516
 
    # The width could not be determined.
1517
 
    return None
 
1468
    return width
1518
1469
 
1519
1470
 
1520
1471
def _win32_terminal_size(width, height):
1547
1498
    _terminal_size = _ioctl_terminal_size
1548
1499
 
1549
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
 
1550
1526
def supports_executable():
1551
1527
    return sys.platform != "win32"
1552
1528
 
1675
1651
        dirblock = []
1676
1652
        append = dirblock.append
1677
1653
        try:
1678
 
            names = sorted(map(decode_filename, _listdir(top)))
 
1654
            names = sorted(_listdir(top))
1679
1655
        except OSError, e:
1680
1656
            if not _is_error_enotdir(e):
1681
1657
                raise
1889
1865
        s = os.stat(src)
1890
1866
        chown(dst, s.st_uid, s.st_gid)
1891
1867
    except OSError, e:
1892
 
        trace.warning(
1893
 
            'Unable to copy ownership from "%s" to "%s". '
1894
 
            'You may want to set it manually.', src, dst)
1895
 
        trace.log_exception_quietly()
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1896
1869
 
1897
1870
 
1898
1871
def path_prefix_key(path):
1986
1959
    return user_encoding
1987
1960
 
1988
1961
 
1989
 
def get_diff_header_encoding():
1990
 
    return get_terminal_encoding()
1991
 
 
1992
 
 
1993
1962
def get_host_name():
1994
1963
    """Return the current unicode host name.
1995
1964
 
2010
1979
# data at once.
2011
1980
MAX_SOCKET_CHUNK = 64 * 1024
2012
1981
 
2013
 
_end_of_stream_errors = [errno.ECONNRESET]
2014
 
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2015
 
    _eno = getattr(errno, _eno, None)
2016
 
    if _eno is not None:
2017
 
        _end_of_stream_errors.append(_eno)
2018
 
del _eno
2019
 
 
2020
 
 
2021
1982
def read_bytes_from_socket(sock, report_activity=None,
2022
1983
        max_read_size=MAX_SOCKET_CHUNK):
2023
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
2031
1992
            bytes = sock.recv(max_read_size)
2032
1993
        except socket.error, e:
2033
1994
            eno = e.args[0]
2034
 
            if eno in _end_of_stream_errors:
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
2035
1996
                # The connection was closed by the other side.  Callers expect
2036
1997
                # an empty string to signal end-of-stream.
2037
1998
                return ""
2066
2027
 
2067
2028
def send_all(sock, bytes, report_activity=None):
2068
2029
    """Send all bytes on a socket.
2069
 
 
 
2030
 
2070
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2071
2032
    some platforms, and catches EINTR which may be thrown if the send is
2072
2033
    interrupted by a signal.
2073
2034
 
2074
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
2075
2036
    and provides activity reporting.
2076
 
 
 
2037
 
2077
2038
    :param report_activity: Call this as bytes are read, see
2078
2039
        Transport._report_activity
2079
2040
    """
2090
2051
            report_activity(sent, 'write')
2091
2052
 
2092
2053
 
2093
 
def connect_socket(address):
2094
 
    # Slight variation of the socket.create_connection() function (provided by
2095
 
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
2096
 
    # provide it for previous python versions. Also, we don't use the timeout
2097
 
    # parameter (provided by the python implementation) so we don't implement
2098
 
    # it either).
2099
 
    err = socket.error('getaddrinfo returns an empty list')
2100
 
    host, port = address
2101
 
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
2102
 
        af, socktype, proto, canonname, sa = res
2103
 
        sock = None
2104
 
        try:
2105
 
            sock = socket.socket(af, socktype, proto)
2106
 
            sock.connect(sa)
2107
 
            return sock
2108
 
 
2109
 
        except socket.error, err:
2110
 
            # 'err' is now the most recent error
2111
 
            if sock is not None:
2112
 
                sock.close()
2113
 
    raise err
2114
 
 
2115
 
 
2116
2054
def dereference_path(path):
2117
2055
    """Determine the real path to a file.
2118
2056
 
2157
2095
    base = dirname(bzrlib.__file__)
2158
2096
    if getattr(sys, 'frozen', None):    # bzr.exe
2159
2097
        base = abspath(pathjoin(base, '..', '..'))
2160
 
    f = file(pathjoin(base, resource_relpath), "rU")
2161
 
    try:
2162
 
        return f.read()
2163
 
    finally:
2164
 
        f.close()
 
2098
    filename = pathjoin(base, resource_relpath)
 
2099
    return open(filename, 'rU').read()
 
2100
 
2165
2101
 
2166
2102
def file_kind_from_stat_mode_thunk(mode):
2167
2103
    global file_kind_from_stat_mode
2190
2126
 
2191
2127
def until_no_eintr(f, *a, **kw):
2192
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2193
 
 
 
2129
    
2194
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
2195
2131
    if EINTR does occur.  This is typically only true for low-level operations
2196
2132
    like os.read.  If in any doubt, don't use this.
2211
2147
            raise
2212
2148
 
2213
2149
 
2214
 
@deprecated_function(deprecated_in((2, 2, 0)))
2215
2150
def re_compile_checked(re_string, flags=0, where=""):
2216
2151
    """Return a compiled re, or raise a sensible error.
2217
2152
 
2227
2162
        re_obj = re.compile(re_string, flags)
2228
2163
        re_obj.search("")
2229
2164
        return re_obj
2230
 
    except errors.InvalidPattern, e:
 
2165
    except re.error, e:
2231
2166
        if where:
2232
2167
            where = ' in ' + where
2233
2168
        # despite the name 'error' is a type
2234
 
        raise errors.BzrCommandError('Invalid regular expression%s: %s'
2235
 
            % (where, e.msg))
 
2169
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
2170
            % (where, re_string, e))
2236
2171
 
2237
2172
 
2238
2173
if sys.platform == "win32":
2252
2187
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2253
2188
        return ch
2254
2189
 
 
2190
 
2255
2191
if sys.platform == 'linux2':
2256
2192
    def _local_concurrency():
2257
 
        try:
2258
 
            return os.sysconf('SC_NPROCESSORS_ONLN')
2259
 
        except (ValueError, OSError, AttributeError):
2260
 
            return None
 
2193
        concurrency = None
 
2194
        prefix = 'processor'
 
2195
        for line in file('/proc/cpuinfo', 'rb'):
 
2196
            if line.startswith(prefix):
 
2197
                concurrency = int(line[line.find(':')+1:]) + 1
 
2198
        return concurrency
2261
2199
elif sys.platform == 'darwin':
2262
2200
    def _local_concurrency():
2263
2201
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2264
2202
                                stdout=subprocess.PIPE).communicate()[0]
2265
 
elif "bsd" in sys.platform:
 
2203
elif sys.platform[0:7] == 'freebsd':
2266
2204
    def _local_concurrency():
2267
2205
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2268
2206
                                stdout=subprocess.PIPE).communicate()[0]
2296
2234
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
2297
2235
    if concurrency is None:
2298
2236
        try:
2299
 
            import multiprocessing
2300
 
        except ImportError:
2301
 
            # multiprocessing is only available on Python >= 2.6
2302
 
            try:
2303
 
                concurrency = _local_concurrency()
2304
 
            except (OSError, IOError):
2305
 
                pass
2306
 
        else:
2307
 
            concurrency = multiprocessing.cpu_count()
 
2237
            concurrency = _local_concurrency()
 
2238
        except (OSError, IOError):
 
2239
            pass
2308
2240
    try:
2309
2241
        concurrency = int(concurrency)
2310
2242
    except (TypeError, ValueError):
2331
2263
if sys.platform == 'win32':
2332
2264
    def open_file(filename, mode='r', bufsize=-1):
2333
2265
        """This function is used to override the ``open`` builtin.
2334
 
 
 
2266
        
2335
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2336
2268
        child processes.  Deleting or renaming a closed file opened with this
2337
2269
        function is not blocking child processes.
2370
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2371
2303
else:
2372
2304
    open_file = open
2373
 
 
2374
 
 
2375
 
def getuser_unicode():
2376
 
    """Return the username as unicode.
2377
 
    """
2378
 
    try:
2379
 
        user_encoding = get_user_encoding()
2380
 
        username = getpass.getuser().decode(user_encoding)
2381
 
    except UnicodeDecodeError:
2382
 
        raise errors.BzrError("Can't decode username as %s." % \
2383
 
                user_encoding)
2384
 
    except ImportError, e:
2385
 
        if sys.platform != 'win32':
2386
 
            raise
2387
 
        if str(e) != 'No module named pwd':
2388
 
            raise
2389
 
        # https://bugs.launchpad.net/bzr/+bug/660174
2390
 
        # getpass.getuser() is unable to return username on Windows
2391
 
        # if there is no USERNAME environment variable set.
2392
 
        # That could be true if bzr is running as a service,
2393
 
        # e.g. running `bzr serve` as a service on Windows.
2394
 
        # We should not fail with traceback in this case.
2395
 
        username = u'UNKNOWN'
2396
 
    return username
2397
 
 
2398
 
 
2399
 
def available_backup_name(base, exists):
2400
 
    """Find a non-existing backup file name.
2401
 
 
2402
 
    This will *not* create anything, this only return a 'free' entry.  This
2403
 
    should be used for checking names in a directory below a locked
2404
 
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
2405
 
    Leap) and generally discouraged.
2406
 
 
2407
 
    :param base: The base name.
2408
 
 
2409
 
    :param exists: A callable returning True if the path parameter exists.
2410
 
    """
2411
 
    counter = 1
2412
 
    name = "%s.~%d~" % (base, counter)
2413
 
    while exists(name):
2414
 
        counter += 1
2415
 
        name = "%s.~%d~" % (base, counter)
2416
 
    return name
2417
 
 
2418
 
 
2419
 
def set_fd_cloexec(fd):
2420
 
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
2421
 
    support for this is not available.
2422
 
    """
2423
 
    try:
2424
 
        import fcntl
2425
 
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
2426
 
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
2427
 
    except (ImportError, AttributeError):
2428
 
        # Either the fcntl module or specific constants are not present
2429
 
        pass
2430
 
 
2431
 
 
2432
 
def find_executable_on_path(name):
2433
 
    """Finds an executable on the PATH.
2434
 
    
2435
 
    On Windows, this will try to append each extension in the PATHEXT
2436
 
    environment variable to the name, if it cannot be found with the name
2437
 
    as given.
2438
 
    
2439
 
    :param name: The base name of the executable.
2440
 
    :return: The path to the executable found or None.
2441
 
    """
2442
 
    path = os.environ.get('PATH')
2443
 
    if path is None:
2444
 
        return None
2445
 
    path = path.split(os.pathsep)
2446
 
    if sys.platform == 'win32':
2447
 
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
2448
 
        exts = [ext.lower() for ext in exts]
2449
 
        base, ext = os.path.splitext(name)
2450
 
        if ext != '':
2451
 
            if ext.lower() not in exts:
2452
 
                return None
2453
 
            name = base
2454
 
            exts = [ext]
2455
 
    else:
2456
 
        exts = ['']
2457
 
    for ext in exts:
2458
 
        for d in path:
2459
 
            f = os.path.join(d, name) + ext
2460
 
            if os.access(f, os.X_OK):
2461
 
                return f
2462
 
    return None
2463
 
 
2464
 
 
2465
 
def _posix_is_local_pid_dead(pid):
2466
 
    """True if pid doesn't correspond to live process on this machine"""
2467
 
    try:
2468
 
        # Special meaning of unix kill: just check if it's there.
2469
 
        os.kill(pid, 0)
2470
 
    except OSError, e:
2471
 
        if e.errno == errno.ESRCH:
2472
 
            # On this machine, and really not found: as sure as we can be
2473
 
            # that it's dead.
2474
 
            return True
2475
 
        elif e.errno == errno.EPERM:
2476
 
            # exists, though not ours
2477
 
            return False
2478
 
        else:
2479
 
            mutter("os.kill(%d, 0) failed: %s" % (pid, e))
2480
 
            # Don't really know.
2481
 
            return False
2482
 
    else:
2483
 
        # Exists and our process: not dead.
2484
 
        return False
2485
 
 
2486
 
if sys.platform == "win32":
2487
 
    is_local_pid_dead = win32utils.is_local_pid_dead
2488
 
else:
2489
 
    is_local_pid_dead = _posix_is_local_pid_dead