← 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:44:59 UTC
  • mfrom: (5221 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100511084459-pb0uinna9zs3wu59
Merge trunk - resolve conflicts.

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