/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
 
import select
32
 
# We need to import both shutil and rmtree as we export the later on posix
33
 
# and need the former on windows
34
36
import shutil
35
 
from shutil import rmtree
 
37
from shutil import (
 
38
    rmtree,
 
39
    )
36
40
import socket
37
41
import subprocess
38
 
# We need to import both tempfile and mkdtemp as we export the later on posix
39
 
# and need the former on windows
40
42
import tempfile
41
 
from tempfile import mkdtemp
 
43
from tempfile import (
 
44
    mkdtemp,
 
45
    )
42
46
import unicodedata
43
47
 
44
48
from bzrlib import (
45
49
    cache_utf8,
46
 
    config,
47
50
    errors,
48
51
    trace,
49
52
    win32utils,
50
53
    )
51
 
from bzrlib.i18n import gettext
52
54
""")
53
55
 
54
56
from bzrlib.symbol_versioning import (
56
58
    deprecated_in,
57
59
    )
58
60
 
59
 
from hashlib import (
60
 
    md5,
61
 
    sha1 as sha,
62
 
    )
 
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
        )
63
73
 
64
74
 
65
75
import bzrlib
91
101
        user_encoding = get_user_encoding()
92
102
        return [a.decode(user_encoding) for a in sys.argv[1:]]
93
103
    except UnicodeDecodeError:
94
 
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
95
 
            "application locale.").format(a, user_encoding))
 
104
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
105
                                                            "encoding." % a))
96
106
 
97
107
 
98
108
def make_readonly(filename):
100
110
    mod = os.lstat(filename).st_mode
101
111
    if not stat.S_ISLNK(mod):
102
112
        mod = mod & 0777555
103
 
        chmod_if_possible(filename, mod)
 
113
        os.chmod(filename, mod)
104
114
 
105
115
 
106
116
def make_writable(filename):
107
117
    mod = os.lstat(filename).st_mode
108
118
    if not stat.S_ISLNK(mod):
109
119
        mod = mod | 0200
110
 
        chmod_if_possible(filename, mod)
111
 
 
112
 
 
113
 
def chmod_if_possible(filename, mode):
114
 
    # Set file mode if that can be safely done.
115
 
    # Sometimes even on unix the filesystem won't allow it - see
116
 
    # https://bugs.launchpad.net/bzr/+bug/606537
117
 
    try:
118
 
        # It is probably faster to just do the chmod, rather than
119
 
        # doing a stat, and then trying to compare
120
 
        os.chmod(filename, mode)
121
 
    except (IOError, OSError),e:
122
 
        # Permission/access denied seems to commonly happen on smbfs; there's
123
 
        # probably no point warning about it.
124
 
        # <https://bugs.launchpad.net/bzr/+bug/606537>
125
 
        if getattr(e, 'errno') in (errno.EPERM, errno.EACCES):
126
 
            trace.mutter("ignore error on chmod of %r: %r" % (
127
 
                filename, e))
128
 
            return
129
 
        raise
 
120
        os.chmod(filename, mod)
130
121
 
131
122
 
132
123
def minimum_path_selection(paths):
211
202
            if e.errno == errno.ENOENT:
212
203
                return False;
213
204
            else:
214
 
                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))
215
206
 
216
207
 
217
208
def fancy_rename(old, new, rename_func, unlink_func):
283
274
            else:
284
275
                rename_func(tmp_name, new)
285
276
    if failure_exc is not None:
286
 
        try:
287
 
            raise failure_exc[0], failure_exc[1], failure_exc[2]
288
 
        finally:
289
 
            del failure_exc
 
277
        raise failure_exc[0], failure_exc[1], failure_exc[2]
290
278
 
291
279
 
292
280
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
299
287
    # copy posixpath.abspath, but use os.getcwdu instead
300
288
    if not posixpath.isabs(path):
301
289
        path = posixpath.join(getcwd(), path)
302
 
    return _posix_normpath(path)
 
290
    return posixpath.normpath(path)
303
291
 
304
292
 
305
293
def _posix_realpath(path):
306
294
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
307
295
 
308
296
 
309
 
def _posix_normpath(path):
310
 
    path = posixpath.normpath(path)
311
 
    # Bug 861008: posixpath.normpath() returns a path normalized according to
312
 
    # the POSIX standard, which stipulates (for compatibility reasons) that two
313
 
    # leading slashes must not be simplified to one, and only if there are 3 or
314
 
    # more should they be simplified as one. So we treat the leading 2 slashes
315
 
    # as a special case here by simply removing the first slash, as we consider
316
 
    # that breaking POSIX compatibility for this obscure feature is acceptable.
317
 
    # This is not a paranoid precaution, as we notably get paths like this when
318
 
    # the repo is hosted at the root of the filesystem, i.e. in "/".    
319
 
    if path.startswith('//'):
320
 
        path = path[1:]
321
 
    return path
322
 
 
323
 
 
324
297
def _win32_fixdrive(path):
325
298
    """Force drive letters to be consistent.
326
299
 
330
303
    running python.exe under cmd.exe return capital C:\\
331
304
    running win32 python inside a cygwin shell returns lowercase c:\\
332
305
    """
333
 
    drive, path = ntpath.splitdrive(path)
 
306
    drive, path = _nt_splitdrive(path)
334
307
    return drive.upper() + path
335
308
 
336
309
 
337
310
def _win32_abspath(path):
338
 
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
339
 
    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('\\', '/'))
340
313
 
341
314
 
342
315
def _win98_abspath(path):
353
326
    #   /path       => C:/path
354
327
    path = unicode(path)
355
328
    # check for absolute path
356
 
    drive = ntpath.splitdrive(path)[0]
 
329
    drive = _nt_splitdrive(path)[0]
357
330
    if drive == '' and path[:2] not in('//','\\\\'):
358
331
        cwd = os.getcwdu()
359
332
        # we cannot simply os.path.join cwd and path
360
333
        # because os.path.join('C:','/path') produce '/path'
361
334
        # and this is incorrect
362
335
        if path[:1] in ('/','\\'):
363
 
            cwd = ntpath.splitdrive(cwd)[0]
 
336
            cwd = _nt_splitdrive(cwd)[0]
364
337
            path = path[1:]
365
338
        path = cwd + '\\' + path
366
 
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
 
339
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
367
340
 
368
341
 
369
342
def _win32_realpath(path):
370
 
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
371
 
    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('\\', '/'))
372
345
 
373
346
 
374
347
def _win32_pathjoin(*args):
375
 
    return ntpath.join(*args).replace('\\', '/')
 
348
    return _nt_join(*args).replace('\\', '/')
376
349
 
377
350
 
378
351
def _win32_normpath(path):
379
 
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
 
352
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
380
353
 
381
354
 
382
355
def _win32_getcwd():
387
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
388
361
 
389
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
 
390
371
def _win32_rename(old, new):
391
372
    """We expect to be able to atomically replace 'new' with old.
392
373
 
394
375
    and then deleted.
395
376
    """
396
377
    try:
397
 
        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)
398
379
    except OSError, e:
399
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
400
381
            # If we try to rename a non-existant file onto cwd, we get
405
386
        raise
406
387
 
407
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
 
408
399
def _mac_getcwd():
409
400
    return unicodedata.normalize('NFC', os.getcwdu())
410
401
 
414
405
abspath = _posix_abspath
415
406
realpath = _posix_realpath
416
407
pathjoin = os.path.join
417
 
normpath = _posix_normpath
 
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
418
410
getcwd = os.getcwdu
419
 
rename = os.rename
420
411
dirname = os.path.dirname
421
412
basename = os.path.basename
422
413
split = os.path.split
423
414
splitext = os.path.splitext
424
 
# These were already lazily imported into local scope
 
415
# These were already imported into local scope
425
416
# mkdtemp = tempfile.mkdtemp
426
417
# rmtree = shutil.rmtree
427
 
lstat = os.lstat
428
 
fstat = os.fstat
429
 
 
430
 
def wrap_stat(st):
431
 
    return st
432
 
 
433
418
 
434
419
MIN_ABS_PATHLENGTH = 1
435
420
 
445
430
    getcwd = _win32_getcwd
446
431
    mkdtemp = _win32_mkdtemp
447
432
    rename = _win32_rename
448
 
    try:
449
 
        from bzrlib import _walkdirs_win32
450
 
    except ImportError:
451
 
        pass
452
 
    else:
453
 
        lstat = _walkdirs_win32.lstat
454
 
        fstat = _walkdirs_win32.fstat
455
 
        wrap_stat = _walkdirs_win32.wrap_stat
456
433
 
457
434
    MIN_ABS_PATHLENGTH = 3
458
435
 
481
458
    getcwd = _mac_getcwd
482
459
 
483
460
 
484
 
def get_terminal_encoding(trace=False):
 
461
def get_terminal_encoding():
485
462
    """Find the best encoding for printing to the screen.
486
463
 
487
464
    This attempts to check both sys.stdout and sys.stdin to see
493
470
 
494
471
    On my standard US Windows XP, the preferred encoding is
495
472
    cp1252, but the console is cp437
496
 
 
497
 
    :param trace: If True trace the selected encoding via mutter().
498
473
    """
499
474
    from bzrlib.trace import mutter
500
475
    output_encoding = getattr(sys.stdout, 'encoding', None)
502
477
        input_encoding = getattr(sys.stdin, 'encoding', None)
503
478
        if not input_encoding:
504
479
            output_encoding = get_user_encoding()
505
 
            if trace:
506
 
                mutter('encoding stdout as osutils.get_user_encoding() %r',
 
480
            mutter('encoding stdout as osutils.get_user_encoding() %r',
507
481
                   output_encoding)
508
482
        else:
509
483
            output_encoding = input_encoding
510
 
            if trace:
511
 
                mutter('encoding stdout as sys.stdin encoding %r',
512
 
                    output_encoding)
 
484
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
513
485
    else:
514
 
        if trace:
515
 
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
486
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
516
487
    if output_encoding == 'cp0':
517
488
        # invalid encoding (cp0 means 'no codepage' on Windows)
518
489
        output_encoding = get_user_encoding()
519
 
        if trace:
520
 
            mutter('cp0 is invalid encoding.'
 
490
        mutter('cp0 is invalid encoding.'
521
491
               ' encoding stdout as osutils.get_user_encoding() %r',
522
492
               output_encoding)
523
493
    # check encoding
549
519
def isdir(f):
550
520
    """True if f is an accessible directory."""
551
521
    try:
552
 
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
 
522
        return S_ISDIR(os.lstat(f)[ST_MODE])
553
523
    except OSError:
554
524
        return False
555
525
 
557
527
def isfile(f):
558
528
    """True if f is a regular file."""
559
529
    try:
560
 
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
 
530
        return S_ISREG(os.lstat(f)[ST_MODE])
561
531
    except OSError:
562
532
        return False
563
533
 
564
534
def islink(f):
565
535
    """True if f is a symlink."""
566
536
    try:
567
 
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
 
537
        return S_ISLNK(os.lstat(f)[ST_MODE])
568
538
    except OSError:
569
539
        return False
570
540
 
910
880
 
911
881
def filesize(f):
912
882
    """Return size of given open file."""
913
 
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
883
    return os.fstat(f.fileno())[ST_SIZE]
914
884
 
915
885
 
916
886
# Define rand_bytes based on platform.
961
931
    rps = []
962
932
    for f in ps:
963
933
        if f == '..':
964
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
934
            raise errors.BzrError("sorry, %r not allowed in path" % f)
965
935
        elif (f == '.') or (f == ''):
966
936
            pass
967
937
        else:
972
942
def joinpath(p):
973
943
    for f in p:
974
944
        if (f == '..') or (f is None) or (f == ''):
975
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
945
            raise errors.BzrError("sorry, %r not allowed in path" % f)
976
946
    return pathjoin(*p)
977
947
 
978
948
 
979
949
def parent_directories(filename):
980
950
    """Return the list of parent directories, deepest first.
981
 
 
 
951
    
982
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
983
953
    """
984
954
    parents = []
1008
978
    # NB: This docstring is just an example, not a doctest, because doctest
1009
979
    # currently can't cope with the use of lazy imports in this namespace --
1010
980
    # mbp 20090729
1011
 
 
 
981
    
1012
982
    # This currently doesn't report the failure at the time it occurs, because
1013
983
    # they tend to happen very early in startup when we can't check config
1014
984
    # files etc, and also we want to report all failures but not spam the user
1015
985
    # with 10 warnings.
 
986
    from bzrlib import trace
1016
987
    exception_str = str(exception)
1017
988
    if exception_str not in _extension_load_failures:
1018
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
1022
993
def report_extension_load_failures():
1023
994
    if not _extension_load_failures:
1024
995
        return
1025
 
    if config.GlobalStack().get('ignore_missing_extensions'):
 
996
    from bzrlib.config import GlobalConfig
 
997
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
1026
998
        return
1027
999
    # the warnings framework should by default show this only once
1028
1000
    from bzrlib.trace import warning
1082
1054
 
1083
1055
 
1084
1056
def delete_any(path):
1085
 
    """Delete a file, symlink or directory.
1086
 
 
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
1087
1059
    Will delete even if readonly.
1088
1060
    """
1089
1061
    try:
1190
1162
 
1191
1163
    if len(base) < MIN_ABS_PATHLENGTH:
1192
1164
        # must have space for e.g. a drive letter
1193
 
        raise ValueError(gettext('%r is too short to calculate a relative path')
 
1165
        raise ValueError('%r is too short to calculate a relative path'
1194
1166
            % (base,))
1195
1167
 
1196
1168
    rp = abspath(path)
1278
1250
    # but for now, we haven't optimized...
1279
1251
    return [canonical_relpath(base, p) for p in paths]
1280
1252
 
1281
 
 
1282
 
def decode_filename(filename):
1283
 
    """Decode the filename using the filesystem encoding
1284
 
 
1285
 
    If it is unicode, it is returned.
1286
 
    Otherwise it is decoded from the the filesystem's encoding. If decoding
1287
 
    fails, a errors.BadFilenameEncoding exception is raised.
1288
 
    """
1289
 
    if type(filename) is unicode:
1290
 
        return filename
1291
 
    try:
1292
 
        return filename.decode(_fs_enc)
1293
 
    except UnicodeDecodeError:
1294
 
        raise errors.BadFilenameEncoding(filename, _fs_enc)
1295
 
 
1296
 
 
1297
1253
def safe_unicode(unicode_or_utf8_string):
1298
1254
    """Coerce unicode_or_utf8_string into unicode.
1299
1255
 
1382
1338
def normalizes_filenames():
1383
1339
    """Return True if this platform normalizes unicode filenames.
1384
1340
 
1385
 
    Only Mac OSX.
 
1341
    Mac OSX does, Windows/Linux do not.
1386
1342
    """
1387
1343
    return _platform_normalizes_filenames
1388
1344
 
1393
1349
    On platforms where the system normalizes filenames (Mac OSX),
1394
1350
    you can access a file by any path which will normalize correctly.
1395
1351
    On platforms where the system does not normalize filenames
1396
 
    (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.
1397
1353
 
1398
1354
    Internally, bzr only supports NFC normalization, since that is
1399
1355
    the standard for XML documents.
1461
1417
terminal_width() returns None.
1462
1418
"""
1463
1419
 
1464
 
# Keep some state so that terminal_width can detect if _terminal_size has
1465
 
# returned a different size since the process started.  See docstring and
1466
 
# comments of terminal_width for details.
1467
 
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1468
 
_terminal_size_state = 'no_data'
1469
 
_first_terminal_size = None
1470
1420
 
1471
1421
def terminal_width():
1472
1422
    """Return terminal width.
1476
1426
    The rules are:
1477
1427
    - if BZR_COLUMNS is set, returns its value
1478
1428
    - if there is no controlling terminal, returns None
1479
 
    - query the OS, if the queried size has changed since the last query,
1480
 
      return its value,
1481
1429
    - if COLUMNS is set, returns its value,
1482
 
    - if the OS has a value (even though it's never changed), return its value.
1483
1430
 
1484
1431
    From there, we need to query the OS to get the size of the controlling
1485
1432
    terminal.
1486
1433
 
1487
 
    On Unices we query the OS by:
 
1434
    Unices:
1488
1435
    - get termios.TIOCGWINSZ
1489
1436
    - if an error occurs or a negative value is obtained, returns None
1490
1437
 
1491
 
    On Windows we query the OS by:
 
1438
    Windows:
 
1439
    
1492
1440
    - win32utils.get_console_size() decides,
1493
1441
    - returns None on error (provided default value)
1494
1442
    """
1495
 
    # Note to implementors: if changing the rules for determining the width,
1496
 
    # make sure you've considered the behaviour in these cases:
1497
 
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1498
 
    #  - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1499
 
    #    0,0.
1500
 
    #  - (add more interesting cases here, if you find any)
1501
 
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1502
 
    # but we don't want to register a signal handler because it is impossible
1503
 
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
1504
 
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
1505
 
    # time so we can notice if the reported size has changed, which should have
1506
 
    # a similar effect.
1507
1443
 
1508
1444
    # If BZR_COLUMNS is set, take it, user is always right
1509
 
    # Except if they specified 0 in which case, impose no limit here
1510
1445
    try:
1511
 
        width = int(os.environ['BZR_COLUMNS'])
 
1446
        return int(os.environ['BZR_COLUMNS'])
1512
1447
    except (KeyError, ValueError):
1513
 
        width = None
1514
 
    if width is not None:
1515
 
        if width > 0:
1516
 
            return width
1517
 
        else:
1518
 
            return None
 
1448
        pass
1519
1449
 
1520
1450
    isatty = getattr(sys.stdout, 'isatty', None)
1521
 
    if isatty is None or not isatty():
 
1451
    if  isatty is None or not isatty():
1522
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
1523
1453
        return None
1524
1454
 
1525
 
    # Query the OS
1526
 
    width, height = os_size = _terminal_size(None, None)
1527
 
    global _first_terminal_size, _terminal_size_state
1528
 
    if _terminal_size_state == 'no_data':
1529
 
        _first_terminal_size = os_size
1530
 
        _terminal_size_state = 'unchanged'
1531
 
    elif (_terminal_size_state == 'unchanged' and
1532
 
          _first_terminal_size != os_size):
1533
 
        _terminal_size_state = 'changed'
1534
 
 
1535
 
    # If the OS claims to know how wide the terminal is, and this value has
1536
 
    # ever changed, use that.
1537
 
    if _terminal_size_state == 'changed':
1538
 
        if width is not None and width > 0:
1539
 
            return width
1540
 
 
1541
 
    # 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))
1542
1458
    try:
1543
1459
        return int(os.environ['COLUMNS'])
1544
1460
    except (KeyError, ValueError):
1545
1461
        pass
1546
1462
 
1547
 
    # Finally, use an unchanged size from the OS, if we have one.
1548
 
    if _terminal_size_state == 'unchanged':
1549
 
        if width is not None and width > 0:
1550
 
            return width
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
1551
1467
 
1552
 
    # The width could not be determined.
1553
 
    return None
 
1468
    return width
1554
1469
 
1555
1470
 
1556
1471
def _win32_terminal_size(width, height):
1583
1498
    _terminal_size = _ioctl_terminal_size
1584
1499
 
1585
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
 
1586
1526
def supports_executable():
1587
1527
    return sys.platform != "win32"
1588
1528
 
1711
1651
        dirblock = []
1712
1652
        append = dirblock.append
1713
1653
        try:
1714
 
            names = sorted(map(decode_filename, _listdir(top)))
 
1654
            names = sorted(_listdir(top))
1715
1655
        except OSError, e:
1716
1656
            if not _is_error_enotdir(e):
1717
1657
                raise
1925
1865
        s = os.stat(src)
1926
1866
        chown(dst, s.st_uid, s.st_gid)
1927
1867
    except OSError, e:
1928
 
        trace.warning(
1929
 
            'Unable to copy ownership from "%s" to "%s". '
1930
 
            'You may want to set it manually.', src, dst)
1931
 
        trace.log_exception_quietly()
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1932
1869
 
1933
1870
 
1934
1871
def path_prefix_key(path):
2022
1959
    return user_encoding
2023
1960
 
2024
1961
 
2025
 
def get_diff_header_encoding():
2026
 
    return get_terminal_encoding()
2027
 
 
2028
 
 
2029
 
_message_encoding = None
2030
 
 
2031
 
 
2032
 
def get_message_encoding():
2033
 
    """Return the encoding used for messages
2034
 
 
2035
 
    While the message encoding is a general setting it should usually only be
2036
 
    needed for decoding system error strings such as from OSError instances.
2037
 
    """
2038
 
    global _message_encoding
2039
 
    if _message_encoding is None:
2040
 
        if os.name == "posix":
2041
 
            import locale
2042
 
            # This is a process-global setting that can change, but should in
2043
 
            # general just get set once at process startup then be constant.
2044
 
            _message_encoding = locale.getlocale(locale.LC_MESSAGES)[1]
2045
 
        else:
2046
 
            # On windows want the result of GetACP() which this boils down to.
2047
 
            _message_encoding = get_user_encoding()
2048
 
    return _message_encoding or "ascii"
2049
 
        
2050
 
 
2051
1962
def get_host_name():
2052
1963
    """Return the current unicode host name.
2053
1964
 
2068
1979
# data at once.
2069
1980
MAX_SOCKET_CHUNK = 64 * 1024
2070
1981
 
2071
 
_end_of_stream_errors = [errno.ECONNRESET]
2072
 
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2073
 
    _eno = getattr(errno, _eno, None)
2074
 
    if _eno is not None:
2075
 
        _end_of_stream_errors.append(_eno)
2076
 
del _eno
2077
 
 
2078
 
 
2079
1982
def read_bytes_from_socket(sock, report_activity=None,
2080
1983
        max_read_size=MAX_SOCKET_CHUNK):
2081
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
2089
1992
            bytes = sock.recv(max_read_size)
2090
1993
        except socket.error, e:
2091
1994
            eno = e.args[0]
2092
 
            if eno in _end_of_stream_errors:
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
2093
1996
                # The connection was closed by the other side.  Callers expect
2094
1997
                # an empty string to signal end-of-stream.
2095
1998
                return ""
2124
2027
 
2125
2028
def send_all(sock, bytes, report_activity=None):
2126
2029
    """Send all bytes on a socket.
2127
 
 
 
2030
 
2128
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2129
2032
    some platforms, and catches EINTR which may be thrown if the send is
2130
2033
    interrupted by a signal.
2131
2034
 
2132
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
2133
2036
    and provides activity reporting.
2134
 
 
 
2037
 
2135
2038
    :param report_activity: Call this as bytes are read, see
2136
2039
        Transport._report_activity
2137
2040
    """
2148
2051
            report_activity(sent, 'write')
2149
2052
 
2150
2053
 
2151
 
def connect_socket(address):
2152
 
    # Slight variation of the socket.create_connection() function (provided by
2153
 
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
2154
 
    # provide it for previous python versions. Also, we don't use the timeout
2155
 
    # parameter (provided by the python implementation) so we don't implement
2156
 
    # it either).
2157
 
    err = socket.error('getaddrinfo returns an empty list')
2158
 
    host, port = address
2159
 
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
2160
 
        af, socktype, proto, canonname, sa = res
2161
 
        sock = None
2162
 
        try:
2163
 
            sock = socket.socket(af, socktype, proto)
2164
 
            sock.connect(sa)
2165
 
            return sock
2166
 
 
2167
 
        except socket.error, err:
2168
 
            # 'err' is now the most recent error
2169
 
            if sock is not None:
2170
 
                sock.close()
2171
 
    raise err
2172
 
 
2173
 
 
2174
2054
def dereference_path(path):
2175
2055
    """Determine the real path to a file.
2176
2056
 
2215
2095
    base = dirname(bzrlib.__file__)
2216
2096
    if getattr(sys, 'frozen', None):    # bzr.exe
2217
2097
        base = abspath(pathjoin(base, '..', '..'))
2218
 
    f = file(pathjoin(base, resource_relpath), "rU")
2219
 
    try:
2220
 
        return f.read()
2221
 
    finally:
2222
 
        f.close()
 
2098
    filename = pathjoin(base, resource_relpath)
 
2099
    return open(filename, 'rU').read()
 
2100
 
2223
2101
 
2224
2102
def file_kind_from_stat_mode_thunk(mode):
2225
2103
    global file_kind_from_stat_mode
2236
2114
    return file_kind_from_stat_mode(mode)
2237
2115
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2238
2116
 
2239
 
def file_stat(f, _lstat=os.lstat):
 
2117
 
 
2118
def file_kind(f, _lstat=os.lstat):
2240
2119
    try:
2241
 
        # XXX cache?
2242
 
        return _lstat(f)
 
2120
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2243
2121
    except OSError, e:
2244
2122
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2245
2123
            raise errors.NoSuchFile(f)
2246
2124
        raise
2247
2125
 
2248
 
def file_kind(f, _lstat=os.lstat):
2249
 
    stat_value = file_stat(f, _lstat)
2250
 
    return file_kind_from_stat_mode(stat_value.st_mode)
2251
2126
 
2252
2127
def until_no_eintr(f, *a, **kw):
2253
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2254
 
 
 
2129
    
2255
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
2256
2131
    if EINTR does occur.  This is typically only true for low-level operations
2257
2132
    like os.read.  If in any doubt, don't use this.
2272
2147
            raise
2273
2148
 
2274
2149
 
2275
 
@deprecated_function(deprecated_in((2, 2, 0)))
2276
2150
def re_compile_checked(re_string, flags=0, where=""):
2277
2151
    """Return a compiled re, or raise a sensible error.
2278
2152
 
2288
2162
        re_obj = re.compile(re_string, flags)
2289
2163
        re_obj.search("")
2290
2164
        return re_obj
2291
 
    except errors.InvalidPattern, e:
 
2165
    except re.error, e:
2292
2166
        if where:
2293
2167
            where = ' in ' + where
2294
2168
        # despite the name 'error' is a type
2295
 
        raise errors.BzrCommandError('Invalid regular expression%s: %s'
2296
 
            % (where, e.msg))
 
2169
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
2170
            % (where, re_string, e))
2297
2171
 
2298
2172
 
2299
2173
if sys.platform == "win32":
2313
2187
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2314
2188
        return ch
2315
2189
 
2316
 
if sys.platform.startswith('linux'):
 
2190
 
 
2191
if sys.platform == 'linux2':
2317
2192
    def _local_concurrency():
2318
 
        try:
2319
 
            return os.sysconf('SC_NPROCESSORS_ONLN')
2320
 
        except (ValueError, OSError, AttributeError):
2321
 
            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
2322
2199
elif sys.platform == 'darwin':
2323
2200
    def _local_concurrency():
2324
2201
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2325
2202
                                stdout=subprocess.PIPE).communicate()[0]
2326
 
elif "bsd" in sys.platform:
 
2203
elif sys.platform[0:7] == 'freebsd':
2327
2204
    def _local_concurrency():
2328
2205
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2329
2206
                                stdout=subprocess.PIPE).communicate()[0]
2357
2234
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
2358
2235
    if concurrency is None:
2359
2236
        try:
2360
 
            import multiprocessing
2361
 
            concurrency = multiprocessing.cpu_count()
2362
 
        except (ImportError, NotImplementedError):
2363
 
            # multiprocessing is only available on Python >= 2.6
2364
 
            # and multiprocessing.cpu_count() isn't implemented on all
2365
 
            # platforms
2366
 
            try:
2367
 
                concurrency = _local_concurrency()
2368
 
            except (OSError, IOError):
2369
 
                pass
 
2237
            concurrency = _local_concurrency()
 
2238
        except (OSError, IOError):
 
2239
            pass
2370
2240
    try:
2371
2241
        concurrency = int(concurrency)
2372
2242
    except (TypeError, ValueError):
2393
2263
if sys.platform == 'win32':
2394
2264
    def open_file(filename, mode='r', bufsize=-1):
2395
2265
        """This function is used to override the ``open`` builtin.
2396
 
 
 
2266
        
2397
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2398
2268
        child processes.  Deleting or renaming a closed file opened with this
2399
2269
        function is not blocking child processes.
2432
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2433
2303
else:
2434
2304
    open_file = open
2435
 
 
2436
 
 
2437
 
def getuser_unicode():
2438
 
    """Return the username as unicode.
2439
 
    """
2440
 
    try:
2441
 
        user_encoding = get_user_encoding()
2442
 
        username = getpass.getuser().decode(user_encoding)
2443
 
    except UnicodeDecodeError:
2444
 
        raise errors.BzrError("Can't decode username as %s." % \
2445
 
                user_encoding)
2446
 
    except ImportError, e:
2447
 
        if sys.platform != 'win32':
2448
 
            raise
2449
 
        if str(e) != 'No module named pwd':
2450
 
            raise
2451
 
        # https://bugs.launchpad.net/bzr/+bug/660174
2452
 
        # getpass.getuser() is unable to return username on Windows
2453
 
        # if there is no USERNAME environment variable set.
2454
 
        # That could be true if bzr is running as a service,
2455
 
        # e.g. running `bzr serve` as a service on Windows.
2456
 
        # We should not fail with traceback in this case.
2457
 
        username = u'UNKNOWN'
2458
 
    return username
2459
 
 
2460
 
 
2461
 
def available_backup_name(base, exists):
2462
 
    """Find a non-existing backup file name.
2463
 
 
2464
 
    This will *not* create anything, this only return a 'free' entry.  This
2465
 
    should be used for checking names in a directory below a locked
2466
 
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
2467
 
    Leap) and generally discouraged.
2468
 
 
2469
 
    :param base: The base name.
2470
 
 
2471
 
    :param exists: A callable returning True if the path parameter exists.
2472
 
    """
2473
 
    counter = 1
2474
 
    name = "%s.~%d~" % (base, counter)
2475
 
    while exists(name):
2476
 
        counter += 1
2477
 
        name = "%s.~%d~" % (base, counter)
2478
 
    return name
2479
 
 
2480
 
 
2481
 
def set_fd_cloexec(fd):
2482
 
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
2483
 
    support for this is not available.
2484
 
    """
2485
 
    try:
2486
 
        import fcntl
2487
 
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
2488
 
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
2489
 
    except (ImportError, AttributeError):
2490
 
        # Either the fcntl module or specific constants are not present
2491
 
        pass
2492
 
 
2493
 
 
2494
 
def find_executable_on_path(name):
2495
 
    """Finds an executable on the PATH.
2496
 
    
2497
 
    On Windows, this will try to append each extension in the PATHEXT
2498
 
    environment variable to the name, if it cannot be found with the name
2499
 
    as given.
2500
 
    
2501
 
    :param name: The base name of the executable.
2502
 
    :return: The path to the executable found or None.
2503
 
    """
2504
 
    path = os.environ.get('PATH')
2505
 
    if path is None:
2506
 
        return None
2507
 
    path = path.split(os.pathsep)
2508
 
    if sys.platform == 'win32':
2509
 
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
2510
 
        exts = [ext.lower() for ext in exts]
2511
 
        base, ext = os.path.splitext(name)
2512
 
        if ext != '':
2513
 
            if ext.lower() not in exts:
2514
 
                return None
2515
 
            name = base
2516
 
            exts = [ext]
2517
 
    else:
2518
 
        exts = ['']
2519
 
    for ext in exts:
2520
 
        for d in path:
2521
 
            f = os.path.join(d, name) + ext
2522
 
            if os.access(f, os.X_OK):
2523
 
                return f
2524
 
    return None
2525
 
 
2526
 
 
2527
 
def _posix_is_local_pid_dead(pid):
2528
 
    """True if pid doesn't correspond to live process on this machine"""
2529
 
    try:
2530
 
        # Special meaning of unix kill: just check if it's there.
2531
 
        os.kill(pid, 0)
2532
 
    except OSError, e:
2533
 
        if e.errno == errno.ESRCH:
2534
 
            # On this machine, and really not found: as sure as we can be
2535
 
            # that it's dead.
2536
 
            return True
2537
 
        elif e.errno == errno.EPERM:
2538
 
            # exists, though not ours
2539
 
            return False
2540
 
        else:
2541
 
            mutter("os.kill(%d, 0) failed: %s" % (pid, e))
2542
 
            # Don't really know.
2543
 
            return False
2544
 
    else:
2545
 
        # Exists and our process: not dead.
2546
 
        return False
2547
 
 
2548
 
if sys.platform == "win32":
2549
 
    is_local_pid_dead = win32utils.is_local_pid_dead
2550
 
else:
2551
 
    is_local_pid_dead = _posix_is_local_pid_dead
2552
 
 
2553
 
 
2554
 
def fdatasync(fileno):
2555
 
    """Flush file contents to disk if possible.
2556
 
    
2557
 
    :param fileno: Integer OS file handle.
2558
 
    :raises TransportNotPossible: If flushing to disk is not possible.
2559
 
    """
2560
 
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
2561
 
    if fn is not None:
2562
 
        fn(fileno)
2563
 
 
2564
 
 
2565
 
def ensure_empty_directory_exists(path, exception_class):
2566
 
    """Make sure a local directory exists and is empty.
2567
 
    
2568
 
    If it does not exist, it is created.  If it exists and is not empty, an
2569
 
    instance of exception_class is raised.
2570
 
    """
2571
 
    try:
2572
 
        os.mkdir(path)
2573
 
    except OSError, e:
2574
 
        if e.errno != errno.EEXIST:
2575
 
            raise
2576
 
        if os.listdir(path) != []:
2577
 
            raise exception_class(path)
2578
 
 
2579
 
 
2580
 
def is_environment_error(evalue):
2581
 
    """True if exception instance is due to a process environment issue
2582
 
 
2583
 
    This includes OSError and IOError, but also other errors that come from
2584
 
    the operating system or core libraries but are not subclasses of those.
2585
 
    """
2586
 
    if isinstance(evalue, (EnvironmentError, select.error)):
2587
 
        return True
2588
 
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
2589
 
        return True
2590
 
    return False