/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 (
44
49
    cache_utf8,
45
 
    config,
46
50
    errors,
47
51
    trace,
48
52
    win32utils,
49
53
    )
50
 
from bzrlib.i18n import gettext
51
54
""")
52
55
 
53
56
from bzrlib.symbol_versioning import (
55
58
    deprecated_in,
56
59
    )
57
60
 
58
 
from hashlib import (
59
 
    md5,
60
 
    sha1 as sha,
61
 
    )
 
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
        )
62
73
 
63
74
 
64
75
import bzrlib
90
101
        user_encoding = get_user_encoding()
91
102
        return [a.decode(user_encoding) for a in sys.argv[1:]]
92
103
    except UnicodeDecodeError:
93
 
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
94
 
            "application locale.").format(a, user_encoding))
 
104
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
105
                                                            "encoding." % a))
95
106
 
96
107
 
97
108
def make_readonly(filename):
191
202
            if e.errno == errno.ENOENT:
192
203
                return False;
193
204
            else:
194
 
                raise errors.BzrError(gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
 
205
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
195
206
 
196
207
 
197
208
def fancy_rename(old, new, rename_func, unlink_func):
263
274
            else:
264
275
                rename_func(tmp_name, new)
265
276
    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
 
277
        raise failure_exc[0], failure_exc[1], failure_exc[2]
270
278
 
271
279
 
272
280
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
279
287
    # copy posixpath.abspath, but use os.getcwdu instead
280
288
    if not posixpath.isabs(path):
281
289
        path = posixpath.join(getcwd(), path)
282
 
    return _posix_normpath(path)
 
290
    return posixpath.normpath(path)
283
291
 
284
292
 
285
293
def _posix_realpath(path):
286
294
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
287
295
 
288
296
 
289
 
def _posix_normpath(path):
290
 
    path = posixpath.normpath(path)
291
 
    # Bug 861008: posixpath.normpath() returns a path normalized according to
292
 
    # the POSIX standard, which stipulates (for compatibility reasons) that two
293
 
    # leading slashes must not be simplified to one, and only if there are 3 or
294
 
    # more should they be simplified as one. So we treat the leading 2 slashes
295
 
    # as a special case here by simply removing the first slash, as we consider
296
 
    # that breaking POSIX compatibility for this obscure feature is acceptable.
297
 
    # This is not a paranoid precaution, as we notably get paths like this when
298
 
    # the repo is hosted at the root of the filesystem, i.e. in "/".    
299
 
    if path.startswith('//'):
300
 
        path = path[1:]
301
 
    return path
302
 
 
303
 
 
304
297
def _win32_fixdrive(path):
305
298
    """Force drive letters to be consistent.
306
299
 
310
303
    running python.exe under cmd.exe return capital C:\\
311
304
    running win32 python inside a cygwin shell returns lowercase c:\\
312
305
    """
313
 
    drive, path = ntpath.splitdrive(path)
 
306
    drive, path = _nt_splitdrive(path)
314
307
    return drive.upper() + path
315
308
 
316
309
 
317
310
def _win32_abspath(path):
318
 
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
319
 
    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('\\', '/'))
320
313
 
321
314
 
322
315
def _win98_abspath(path):
333
326
    #   /path       => C:/path
334
327
    path = unicode(path)
335
328
    # check for absolute path
336
 
    drive = ntpath.splitdrive(path)[0]
 
329
    drive = _nt_splitdrive(path)[0]
337
330
    if drive == '' and path[:2] not in('//','\\\\'):
338
331
        cwd = os.getcwdu()
339
332
        # we cannot simply os.path.join cwd and path
340
333
        # because os.path.join('C:','/path') produce '/path'
341
334
        # and this is incorrect
342
335
        if path[:1] in ('/','\\'):
343
 
            cwd = ntpath.splitdrive(cwd)[0]
 
336
            cwd = _nt_splitdrive(cwd)[0]
344
337
            path = path[1:]
345
338
        path = cwd + '\\' + path
346
 
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
 
339
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
347
340
 
348
341
 
349
342
def _win32_realpath(path):
350
 
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
351
 
    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('\\', '/'))
352
345
 
353
346
 
354
347
def _win32_pathjoin(*args):
355
 
    return ntpath.join(*args).replace('\\', '/')
 
348
    return _nt_join(*args).replace('\\', '/')
356
349
 
357
350
 
358
351
def _win32_normpath(path):
359
 
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
 
352
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
360
353
 
361
354
 
362
355
def _win32_getcwd():
367
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
368
361
 
369
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
 
370
371
def _win32_rename(old, new):
371
372
    """We expect to be able to atomically replace 'new' with old.
372
373
 
374
375
    and then deleted.
375
376
    """
376
377
    try:
377
 
        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)
378
379
    except OSError, e:
379
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
380
381
            # If we try to rename a non-existant file onto cwd, we get
385
386
        raise
386
387
 
387
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
 
388
399
def _mac_getcwd():
389
400
    return unicodedata.normalize('NFC', os.getcwdu())
390
401
 
394
405
abspath = _posix_abspath
395
406
realpath = _posix_realpath
396
407
pathjoin = os.path.join
397
 
normpath = _posix_normpath
 
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
398
410
getcwd = os.getcwdu
399
 
rename = os.rename
400
411
dirname = os.path.dirname
401
412
basename = os.path.basename
402
413
split = os.path.split
403
414
splitext = os.path.splitext
404
 
# These were already lazily imported into local scope
 
415
# These were already imported into local scope
405
416
# mkdtemp = tempfile.mkdtemp
406
417
# rmtree = shutil.rmtree
407
 
lstat = os.lstat
408
 
fstat = os.fstat
409
 
 
410
 
def wrap_stat(st):
411
 
    return st
412
 
 
413
418
 
414
419
MIN_ABS_PATHLENGTH = 1
415
420
 
425
430
    getcwd = _win32_getcwd
426
431
    mkdtemp = _win32_mkdtemp
427
432
    rename = _win32_rename
428
 
    try:
429
 
        from bzrlib import _walkdirs_win32
430
 
    except ImportError:
431
 
        pass
432
 
    else:
433
 
        lstat = _walkdirs_win32.lstat
434
 
        fstat = _walkdirs_win32.fstat
435
 
        wrap_stat = _walkdirs_win32.wrap_stat
436
433
 
437
434
    MIN_ABS_PATHLENGTH = 3
438
435
 
461
458
    getcwd = _mac_getcwd
462
459
 
463
460
 
464
 
def get_terminal_encoding(trace=False):
 
461
def get_terminal_encoding():
465
462
    """Find the best encoding for printing to the screen.
466
463
 
467
464
    This attempts to check both sys.stdout and sys.stdin to see
473
470
 
474
471
    On my standard US Windows XP, the preferred encoding is
475
472
    cp1252, but the console is cp437
476
 
 
477
 
    :param trace: If True trace the selected encoding via mutter().
478
473
    """
479
474
    from bzrlib.trace import mutter
480
475
    output_encoding = getattr(sys.stdout, 'encoding', None)
482
477
        input_encoding = getattr(sys.stdin, 'encoding', None)
483
478
        if not input_encoding:
484
479
            output_encoding = get_user_encoding()
485
 
            if trace:
486
 
                mutter('encoding stdout as osutils.get_user_encoding() %r',
 
480
            mutter('encoding stdout as osutils.get_user_encoding() %r',
487
481
                   output_encoding)
488
482
        else:
489
483
            output_encoding = input_encoding
490
 
            if trace:
491
 
                mutter('encoding stdout as sys.stdin encoding %r',
492
 
                    output_encoding)
 
484
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
493
485
    else:
494
 
        if trace:
495
 
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
486
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
496
487
    if output_encoding == 'cp0':
497
488
        # invalid encoding (cp0 means 'no codepage' on Windows)
498
489
        output_encoding = get_user_encoding()
499
 
        if trace:
500
 
            mutter('cp0 is invalid encoding.'
 
490
        mutter('cp0 is invalid encoding.'
501
491
               ' encoding stdout as osutils.get_user_encoding() %r',
502
492
               output_encoding)
503
493
    # check encoding
529
519
def isdir(f):
530
520
    """True if f is an accessible directory."""
531
521
    try:
532
 
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
 
522
        return S_ISDIR(os.lstat(f)[ST_MODE])
533
523
    except OSError:
534
524
        return False
535
525
 
537
527
def isfile(f):
538
528
    """True if f is a regular file."""
539
529
    try:
540
 
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
 
530
        return S_ISREG(os.lstat(f)[ST_MODE])
541
531
    except OSError:
542
532
        return False
543
533
 
544
534
def islink(f):
545
535
    """True if f is a symlink."""
546
536
    try:
547
 
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
 
537
        return S_ISLNK(os.lstat(f)[ST_MODE])
548
538
    except OSError:
549
539
        return False
550
540
 
890
880
 
891
881
def filesize(f):
892
882
    """Return size of given open file."""
893
 
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
883
    return os.fstat(f.fileno())[ST_SIZE]
894
884
 
895
885
 
896
886
# Define rand_bytes based on platform.
941
931
    rps = []
942
932
    for f in ps:
943
933
        if f == '..':
944
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
934
            raise errors.BzrError("sorry, %r not allowed in path" % f)
945
935
        elif (f == '.') or (f == ''):
946
936
            pass
947
937
        else:
952
942
def joinpath(p):
953
943
    for f in p:
954
944
        if (f == '..') or (f is None) or (f == ''):
955
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
945
            raise errors.BzrError("sorry, %r not allowed in path" % f)
956
946
    return pathjoin(*p)
957
947
 
958
948
 
959
949
def parent_directories(filename):
960
950
    """Return the list of parent directories, deepest first.
961
 
 
 
951
    
962
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
963
953
    """
964
954
    parents = []
988
978
    # NB: This docstring is just an example, not a doctest, because doctest
989
979
    # currently can't cope with the use of lazy imports in this namespace --
990
980
    # mbp 20090729
991
 
 
 
981
    
992
982
    # This currently doesn't report the failure at the time it occurs, because
993
983
    # they tend to happen very early in startup when we can't check config
994
984
    # files etc, and also we want to report all failures but not spam the user
995
985
    # with 10 warnings.
 
986
    from bzrlib import trace
996
987
    exception_str = str(exception)
997
988
    if exception_str not in _extension_load_failures:
998
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
1002
993
def report_extension_load_failures():
1003
994
    if not _extension_load_failures:
1004
995
        return
1005
 
    if config.GlobalStack().get('ignore_missing_extensions'):
 
996
    from bzrlib.config import GlobalConfig
 
997
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
1006
998
        return
1007
999
    # the warnings framework should by default show this only once
1008
1000
    from bzrlib.trace import warning
1062
1054
 
1063
1055
 
1064
1056
def delete_any(path):
1065
 
    """Delete a file, symlink or directory.
1066
 
 
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
1067
1059
    Will delete even if readonly.
1068
1060
    """
1069
1061
    try:
1170
1162
 
1171
1163
    if len(base) < MIN_ABS_PATHLENGTH:
1172
1164
        # must have space for e.g. a drive letter
1173
 
        raise ValueError(gettext('%r is too short to calculate a relative path')
 
1165
        raise ValueError('%r is too short to calculate a relative path'
1174
1166
            % (base,))
1175
1167
 
1176
1168
    rp = abspath(path)
1258
1250
    # but for now, we haven't optimized...
1259
1251
    return [canonical_relpath(base, p) for p in paths]
1260
1252
 
1261
 
 
1262
 
def decode_filename(filename):
1263
 
    """Decode the filename using the filesystem encoding
1264
 
 
1265
 
    If it is unicode, it is returned.
1266
 
    Otherwise it is decoded from the the filesystem's encoding. If decoding
1267
 
    fails, a errors.BadFilenameEncoding exception is raised.
1268
 
    """
1269
 
    if type(filename) is unicode:
1270
 
        return filename
1271
 
    try:
1272
 
        return filename.decode(_fs_enc)
1273
 
    except UnicodeDecodeError:
1274
 
        raise errors.BadFilenameEncoding(filename, _fs_enc)
1275
 
 
1276
 
 
1277
1253
def safe_unicode(unicode_or_utf8_string):
1278
1254
    """Coerce unicode_or_utf8_string into unicode.
1279
1255
 
1362
1338
def normalizes_filenames():
1363
1339
    """Return True if this platform normalizes unicode filenames.
1364
1340
 
1365
 
    Only Mac OSX.
 
1341
    Mac OSX does, Windows/Linux do not.
1366
1342
    """
1367
1343
    return _platform_normalizes_filenames
1368
1344
 
1373
1349
    On platforms where the system normalizes filenames (Mac OSX),
1374
1350
    you can access a file by any path which will normalize correctly.
1375
1351
    On platforms where the system does not normalize filenames
1376
 
    (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.
1377
1353
 
1378
1354
    Internally, bzr only supports NFC normalization, since that is
1379
1355
    the standard for XML documents.
1441
1417
terminal_width() returns None.
1442
1418
"""
1443
1419
 
1444
 
# Keep some state so that terminal_width can detect if _terminal_size has
1445
 
# returned a different size since the process started.  See docstring and
1446
 
# comments of terminal_width for details.
1447
 
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1448
 
_terminal_size_state = 'no_data'
1449
 
_first_terminal_size = None
1450
1420
 
1451
1421
def terminal_width():
1452
1422
    """Return terminal width.
1456
1426
    The rules are:
1457
1427
    - if BZR_COLUMNS is set, returns its value
1458
1428
    - if there is no controlling terminal, returns None
1459
 
    - query the OS, if the queried size has changed since the last query,
1460
 
      return its value,
1461
1429
    - if COLUMNS is set, returns its value,
1462
 
    - if the OS has a value (even though it's never changed), return its value.
1463
1430
 
1464
1431
    From there, we need to query the OS to get the size of the controlling
1465
1432
    terminal.
1466
1433
 
1467
 
    On Unices we query the OS by:
 
1434
    Unices:
1468
1435
    - get termios.TIOCGWINSZ
1469
1436
    - if an error occurs or a negative value is obtained, returns None
1470
1437
 
1471
 
    On Windows we query the OS by:
 
1438
    Windows:
 
1439
    
1472
1440
    - win32utils.get_console_size() decides,
1473
1441
    - returns None on error (provided default value)
1474
1442
    """
1475
 
    # Note to implementors: if changing the rules for determining the width,
1476
 
    # make sure you've considered the behaviour in these cases:
1477
 
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1478
 
    #  - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1479
 
    #    0,0.
1480
 
    #  - (add more interesting cases here, if you find any)
1481
 
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1482
 
    # but we don't want to register a signal handler because it is impossible
1483
 
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
1484
 
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
1485
 
    # time so we can notice if the reported size has changed, which should have
1486
 
    # a similar effect.
1487
1443
 
1488
1444
    # If BZR_COLUMNS is set, take it, user is always right
1489
 
    # Except if they specified 0 in which case, impose no limit here
1490
1445
    try:
1491
 
        width = int(os.environ['BZR_COLUMNS'])
 
1446
        return int(os.environ['BZR_COLUMNS'])
1492
1447
    except (KeyError, ValueError):
1493
 
        width = None
1494
 
    if width is not None:
1495
 
        if width > 0:
1496
 
            return width
1497
 
        else:
1498
 
            return None
 
1448
        pass
1499
1449
 
1500
1450
    isatty = getattr(sys.stdout, 'isatty', None)
1501
 
    if isatty is None or not isatty():
 
1451
    if  isatty is None or not isatty():
1502
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
1503
1453
        return None
1504
1454
 
1505
 
    # Query the OS
1506
 
    width, height = os_size = _terminal_size(None, None)
1507
 
    global _first_terminal_size, _terminal_size_state
1508
 
    if _terminal_size_state == 'no_data':
1509
 
        _first_terminal_size = os_size
1510
 
        _terminal_size_state = 'unchanged'
1511
 
    elif (_terminal_size_state == 'unchanged' and
1512
 
          _first_terminal_size != os_size):
1513
 
        _terminal_size_state = 'changed'
1514
 
 
1515
 
    # If the OS claims to know how wide the terminal is, and this value has
1516
 
    # ever changed, use that.
1517
 
    if _terminal_size_state == 'changed':
1518
 
        if width is not None and width > 0:
1519
 
            return width
1520
 
 
1521
 
    # 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))
1522
1458
    try:
1523
1459
        return int(os.environ['COLUMNS'])
1524
1460
    except (KeyError, ValueError):
1525
1461
        pass
1526
1462
 
1527
 
    # Finally, use an unchanged size from the OS, if we have one.
1528
 
    if _terminal_size_state == 'unchanged':
1529
 
        if width is not None and width > 0:
1530
 
            return width
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
1531
1467
 
1532
 
    # The width could not be determined.
1533
 
    return None
 
1468
    return width
1534
1469
 
1535
1470
 
1536
1471
def _win32_terminal_size(width, height):
1563
1498
    _terminal_size = _ioctl_terminal_size
1564
1499
 
1565
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
 
1566
1526
def supports_executable():
1567
1527
    return sys.platform != "win32"
1568
1528
 
1691
1651
        dirblock = []
1692
1652
        append = dirblock.append
1693
1653
        try:
1694
 
            names = sorted(map(decode_filename, _listdir(top)))
 
1654
            names = sorted(_listdir(top))
1695
1655
        except OSError, e:
1696
1656
            if not _is_error_enotdir(e):
1697
1657
                raise
1905
1865
        s = os.stat(src)
1906
1866
        chown(dst, s.st_uid, s.st_gid)
1907
1867
    except OSError, e:
1908
 
        trace.warning(
1909
 
            'Unable to copy ownership from "%s" to "%s". '
1910
 
            'You may want to set it manually.', src, dst)
1911
 
        trace.log_exception_quietly()
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1912
1869
 
1913
1870
 
1914
1871
def path_prefix_key(path):
2002
1959
    return user_encoding
2003
1960
 
2004
1961
 
2005
 
def get_diff_header_encoding():
2006
 
    return get_terminal_encoding()
2007
 
 
2008
 
 
2009
1962
def get_host_name():
2010
1963
    """Return the current unicode host name.
2011
1964
 
2026
1979
# data at once.
2027
1980
MAX_SOCKET_CHUNK = 64 * 1024
2028
1981
 
2029
 
_end_of_stream_errors = [errno.ECONNRESET]
2030
 
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2031
 
    _eno = getattr(errno, _eno, None)
2032
 
    if _eno is not None:
2033
 
        _end_of_stream_errors.append(_eno)
2034
 
del _eno
2035
 
 
2036
 
 
2037
1982
def read_bytes_from_socket(sock, report_activity=None,
2038
1983
        max_read_size=MAX_SOCKET_CHUNK):
2039
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
2047
1992
            bytes = sock.recv(max_read_size)
2048
1993
        except socket.error, e:
2049
1994
            eno = e.args[0]
2050
 
            if eno in _end_of_stream_errors:
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
2051
1996
                # The connection was closed by the other side.  Callers expect
2052
1997
                # an empty string to signal end-of-stream.
2053
1998
                return ""
2082
2027
 
2083
2028
def send_all(sock, bytes, report_activity=None):
2084
2029
    """Send all bytes on a socket.
2085
 
 
 
2030
 
2086
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2087
2032
    some platforms, and catches EINTR which may be thrown if the send is
2088
2033
    interrupted by a signal.
2089
2034
 
2090
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
2091
2036
    and provides activity reporting.
2092
 
 
 
2037
 
2093
2038
    :param report_activity: Call this as bytes are read, see
2094
2039
        Transport._report_activity
2095
2040
    """
2106
2051
            report_activity(sent, 'write')
2107
2052
 
2108
2053
 
2109
 
def connect_socket(address):
2110
 
    # Slight variation of the socket.create_connection() function (provided by
2111
 
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
2112
 
    # provide it for previous python versions. Also, we don't use the timeout
2113
 
    # parameter (provided by the python implementation) so we don't implement
2114
 
    # it either).
2115
 
    err = socket.error('getaddrinfo returns an empty list')
2116
 
    host, port = address
2117
 
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
2118
 
        af, socktype, proto, canonname, sa = res
2119
 
        sock = None
2120
 
        try:
2121
 
            sock = socket.socket(af, socktype, proto)
2122
 
            sock.connect(sa)
2123
 
            return sock
2124
 
 
2125
 
        except socket.error, err:
2126
 
            # 'err' is now the most recent error
2127
 
            if sock is not None:
2128
 
                sock.close()
2129
 
    raise err
2130
 
 
2131
 
 
2132
2054
def dereference_path(path):
2133
2055
    """Determine the real path to a file.
2134
2056
 
2173
2095
    base = dirname(bzrlib.__file__)
2174
2096
    if getattr(sys, 'frozen', None):    # bzr.exe
2175
2097
        base = abspath(pathjoin(base, '..', '..'))
2176
 
    f = file(pathjoin(base, resource_relpath), "rU")
2177
 
    try:
2178
 
        return f.read()
2179
 
    finally:
2180
 
        f.close()
 
2098
    filename = pathjoin(base, resource_relpath)
 
2099
    return open(filename, 'rU').read()
 
2100
 
2181
2101
 
2182
2102
def file_kind_from_stat_mode_thunk(mode):
2183
2103
    global file_kind_from_stat_mode
2194
2114
    return file_kind_from_stat_mode(mode)
2195
2115
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2196
2116
 
2197
 
def file_stat(f, _lstat=os.lstat):
 
2117
 
 
2118
def file_kind(f, _lstat=os.lstat):
2198
2119
    try:
2199
 
        # XXX cache?
2200
 
        return _lstat(f)
 
2120
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2201
2121
    except OSError, e:
2202
2122
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2203
2123
            raise errors.NoSuchFile(f)
2204
2124
        raise
2205
2125
 
2206
 
def file_kind(f, _lstat=os.lstat):
2207
 
    stat_value = file_stat(f, _lstat)
2208
 
    return file_kind_from_stat_mode(stat_value.st_mode)
2209
2126
 
2210
2127
def until_no_eintr(f, *a, **kw):
2211
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2212
 
 
 
2129
    
2213
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
2214
2131
    if EINTR does occur.  This is typically only true for low-level operations
2215
2132
    like os.read.  If in any doubt, don't use this.
2230
2147
            raise
2231
2148
 
2232
2149
 
2233
 
@deprecated_function(deprecated_in((2, 2, 0)))
2234
2150
def re_compile_checked(re_string, flags=0, where=""):
2235
2151
    """Return a compiled re, or raise a sensible error.
2236
2152
 
2246
2162
        re_obj = re.compile(re_string, flags)
2247
2163
        re_obj.search("")
2248
2164
        return re_obj
2249
 
    except errors.InvalidPattern, e:
 
2165
    except re.error, e:
2250
2166
        if where:
2251
2167
            where = ' in ' + where
2252
2168
        # despite the name 'error' is a type
2253
 
        raise errors.BzrCommandError('Invalid regular expression%s: %s'
2254
 
            % (where, e.msg))
 
2169
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
2170
            % (where, re_string, e))
2255
2171
 
2256
2172
 
2257
2173
if sys.platform == "win32":
2271
2187
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2272
2188
        return ch
2273
2189
 
2274
 
if sys.platform.startswith('linux'):
 
2190
 
 
2191
if sys.platform == 'linux2':
2275
2192
    def _local_concurrency():
2276
 
        try:
2277
 
            return os.sysconf('SC_NPROCESSORS_ONLN')
2278
 
        except (ValueError, OSError, AttributeError):
2279
 
            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
2280
2199
elif sys.platform == 'darwin':
2281
2200
    def _local_concurrency():
2282
2201
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2283
2202
                                stdout=subprocess.PIPE).communicate()[0]
2284
 
elif "bsd" in sys.platform:
 
2203
elif sys.platform[0:7] == 'freebsd':
2285
2204
    def _local_concurrency():
2286
2205
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2287
2206
                                stdout=subprocess.PIPE).communicate()[0]
2315
2234
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
2316
2235
    if concurrency is None:
2317
2236
        try:
2318
 
            import multiprocessing
2319
 
            concurrency = multiprocessing.cpu_count()
2320
 
        except (ImportError, NotImplementedError):
2321
 
            # multiprocessing is only available on Python >= 2.6
2322
 
            # and multiprocessing.cpu_count() isn't implemented on all
2323
 
            # platforms
2324
 
            try:
2325
 
                concurrency = _local_concurrency()
2326
 
            except (OSError, IOError):
2327
 
                pass
 
2237
            concurrency = _local_concurrency()
 
2238
        except (OSError, IOError):
 
2239
            pass
2328
2240
    try:
2329
2241
        concurrency = int(concurrency)
2330
2242
    except (TypeError, ValueError):
2351
2263
if sys.platform == 'win32':
2352
2264
    def open_file(filename, mode='r', bufsize=-1):
2353
2265
        """This function is used to override the ``open`` builtin.
2354
 
 
 
2266
        
2355
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2356
2268
        child processes.  Deleting or renaming a closed file opened with this
2357
2269
        function is not blocking child processes.
2390
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2391
2303
else:
2392
2304
    open_file = open
2393
 
 
2394
 
 
2395
 
def getuser_unicode():
2396
 
    """Return the username as unicode.
2397
 
    """
2398
 
    try:
2399
 
        user_encoding = get_user_encoding()
2400
 
        username = getpass.getuser().decode(user_encoding)
2401
 
    except UnicodeDecodeError:
2402
 
        raise errors.BzrError("Can't decode username as %s." % \
2403
 
                user_encoding)
2404
 
    except ImportError, e:
2405
 
        if sys.platform != 'win32':
2406
 
            raise
2407
 
        if str(e) != 'No module named pwd':
2408
 
            raise
2409
 
        # https://bugs.launchpad.net/bzr/+bug/660174
2410
 
        # getpass.getuser() is unable to return username on Windows
2411
 
        # if there is no USERNAME environment variable set.
2412
 
        # That could be true if bzr is running as a service,
2413
 
        # e.g. running `bzr serve` as a service on Windows.
2414
 
        # We should not fail with traceback in this case.
2415
 
        username = u'UNKNOWN'
2416
 
    return username
2417
 
 
2418
 
 
2419
 
def available_backup_name(base, exists):
2420
 
    """Find a non-existing backup file name.
2421
 
 
2422
 
    This will *not* create anything, this only return a 'free' entry.  This
2423
 
    should be used for checking names in a directory below a locked
2424
 
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
2425
 
    Leap) and generally discouraged.
2426
 
 
2427
 
    :param base: The base name.
2428
 
 
2429
 
    :param exists: A callable returning True if the path parameter exists.
2430
 
    """
2431
 
    counter = 1
2432
 
    name = "%s.~%d~" % (base, counter)
2433
 
    while exists(name):
2434
 
        counter += 1
2435
 
        name = "%s.~%d~" % (base, counter)
2436
 
    return name
2437
 
 
2438
 
 
2439
 
def set_fd_cloexec(fd):
2440
 
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
2441
 
    support for this is not available.
2442
 
    """
2443
 
    try:
2444
 
        import fcntl
2445
 
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
2446
 
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
2447
 
    except (ImportError, AttributeError):
2448
 
        # Either the fcntl module or specific constants are not present
2449
 
        pass
2450
 
 
2451
 
 
2452
 
def find_executable_on_path(name):
2453
 
    """Finds an executable on the PATH.
2454
 
    
2455
 
    On Windows, this will try to append each extension in the PATHEXT
2456
 
    environment variable to the name, if it cannot be found with the name
2457
 
    as given.
2458
 
    
2459
 
    :param name: The base name of the executable.
2460
 
    :return: The path to the executable found or None.
2461
 
    """
2462
 
    path = os.environ.get('PATH')
2463
 
    if path is None:
2464
 
        return None
2465
 
    path = path.split(os.pathsep)
2466
 
    if sys.platform == 'win32':
2467
 
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
2468
 
        exts = [ext.lower() for ext in exts]
2469
 
        base, ext = os.path.splitext(name)
2470
 
        if ext != '':
2471
 
            if ext.lower() not in exts:
2472
 
                return None
2473
 
            name = base
2474
 
            exts = [ext]
2475
 
    else:
2476
 
        exts = ['']
2477
 
    for ext in exts:
2478
 
        for d in path:
2479
 
            f = os.path.join(d, name) + ext
2480
 
            if os.access(f, os.X_OK):
2481
 
                return f
2482
 
    return None
2483
 
 
2484
 
 
2485
 
def _posix_is_local_pid_dead(pid):
2486
 
    """True if pid doesn't correspond to live process on this machine"""
2487
 
    try:
2488
 
        # Special meaning of unix kill: just check if it's there.
2489
 
        os.kill(pid, 0)
2490
 
    except OSError, e:
2491
 
        if e.errno == errno.ESRCH:
2492
 
            # On this machine, and really not found: as sure as we can be
2493
 
            # that it's dead.
2494
 
            return True
2495
 
        elif e.errno == errno.EPERM:
2496
 
            # exists, though not ours
2497
 
            return False
2498
 
        else:
2499
 
            mutter("os.kill(%d, 0) failed: %s" % (pid, e))
2500
 
            # Don't really know.
2501
 
            return False
2502
 
    else:
2503
 
        # Exists and our process: not dead.
2504
 
        return False
2505
 
 
2506
 
if sys.platform == "win32":
2507
 
    is_local_pid_dead = win32utils.is_local_pid_dead
2508
 
else:
2509
 
    is_local_pid_dead = _posix_is_local_pid_dead
2510
 
 
2511
 
 
2512
 
def fdatasync(fileno):
2513
 
    """Flush file contents to disk if possible.
2514
 
    
2515
 
    :param fileno: Integer OS file handle.
2516
 
    :raises TransportNotPossible: If flushing to disk is not possible.
2517
 
    """
2518
 
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
2519
 
    if fn is not None:
2520
 
        fn(fileno)