/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
 
from __future__ import absolute_import
18
 
 
19
 
import errno
20
17
import os
21
18
import re
22
19
import stat
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
23
21
import sys
24
22
import time
25
23
import codecs
27
25
from bzrlib.lazy_import import lazy_import
28
26
lazy_import(globals(), """
29
27
from datetime import datetime
30
 
import getpass
31
 
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
                    )
32
35
import posixpath
33
 
import select
34
 
# We need to import both shutil and rmtree as we export the later on posix
35
 
# and need the former on windows
36
36
import shutil
37
 
from shutil import rmtree
 
37
from shutil import (
 
38
    rmtree,
 
39
    )
38
40
import socket
39
41
import subprocess
40
 
# We need to import both tempfile and mkdtemp as we export the later on posix
41
 
# and need the former on windows
42
42
import tempfile
43
 
from tempfile import mkdtemp
 
43
from tempfile import (
 
44
    mkdtemp,
 
45
    )
44
46
import unicodedata
45
47
 
46
48
from bzrlib import (
47
49
    cache_utf8,
48
 
    config,
49
50
    errors,
50
51
    trace,
51
52
    win32utils,
52
53
    )
53
 
from bzrlib.i18n import gettext
54
54
""")
55
55
 
56
56
from bzrlib.symbol_versioning import (
58
58
    deprecated_in,
59
59
    )
60
60
 
61
 
from hashlib import (
62
 
    md5,
63
 
    sha1 as sha,
64
 
    )
 
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
        )
65
73
 
66
74
 
67
75
import bzrlib
68
 
from bzrlib import symbol_versioning, _fs_enc
 
76
from bzrlib import symbol_versioning
69
77
 
70
78
 
71
79
# Cross platform wall-clock time functionality with decent resolution.
93
101
        user_encoding = get_user_encoding()
94
102
        return [a.decode(user_encoding) for a in sys.argv[1:]]
95
103
    except UnicodeDecodeError:
96
 
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
97
 
            "application locale.").format(a, user_encoding))
 
104
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
105
                                                            "encoding." % a))
98
106
 
99
107
 
100
108
def make_readonly(filename):
102
110
    mod = os.lstat(filename).st_mode
103
111
    if not stat.S_ISLNK(mod):
104
112
        mod = mod & 0777555
105
 
        chmod_if_possible(filename, mod)
 
113
        os.chmod(filename, mod)
106
114
 
107
115
 
108
116
def make_writable(filename):
109
117
    mod = os.lstat(filename).st_mode
110
118
    if not stat.S_ISLNK(mod):
111
119
        mod = mod | 0200
112
 
        chmod_if_possible(filename, mod)
113
 
 
114
 
 
115
 
def chmod_if_possible(filename, mode):
116
 
    # Set file mode if that can be safely done.
117
 
    # Sometimes even on unix the filesystem won't allow it - see
118
 
    # https://bugs.launchpad.net/bzr/+bug/606537
119
 
    try:
120
 
        # It is probably faster to just do the chmod, rather than
121
 
        # doing a stat, and then trying to compare
122
 
        os.chmod(filename, mode)
123
 
    except (IOError, OSError),e:
124
 
        # Permission/access denied seems to commonly happen on smbfs; there's
125
 
        # probably no point warning about it.
126
 
        # <https://bugs.launchpad.net/bzr/+bug/606537>
127
 
        if getattr(e, 'errno') in (errno.EPERM, errno.EACCES):
128
 
            trace.mutter("ignore error on chmod of %r: %r" % (
129
 
                filename, e))
130
 
            return
131
 
        raise
 
120
        os.chmod(filename, mod)
132
121
 
133
122
 
134
123
def minimum_path_selection(paths):
213
202
            if e.errno == errno.ENOENT:
214
203
                return False;
215
204
            else:
216
 
                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))
217
206
 
218
207
 
219
208
def fancy_rename(old, new, rename_func, unlink_func):
285
274
            else:
286
275
                rename_func(tmp_name, new)
287
276
    if failure_exc is not None:
288
 
        try:
289
 
            raise failure_exc[0], failure_exc[1], failure_exc[2]
290
 
        finally:
291
 
            del failure_exc
 
277
        raise failure_exc[0], failure_exc[1], failure_exc[2]
292
278
 
293
279
 
294
280
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
295
281
# choke on a Unicode string containing a relative path if
296
282
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
297
283
# string.
 
284
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
298
285
def _posix_abspath(path):
299
286
    # jam 20060426 rather than encoding to fsencoding
300
287
    # copy posixpath.abspath, but use os.getcwdu instead
301
288
    if not posixpath.isabs(path):
302
289
        path = posixpath.join(getcwd(), path)
303
 
    return _posix_normpath(path)
 
290
    return posixpath.normpath(path)
304
291
 
305
292
 
306
293
def _posix_realpath(path):
307
294
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
308
295
 
309
296
 
310
 
def _posix_normpath(path):
311
 
    path = posixpath.normpath(path)
312
 
    # Bug 861008: posixpath.normpath() returns a path normalized according to
313
 
    # the POSIX standard, which stipulates (for compatibility reasons) that two
314
 
    # leading slashes must not be simplified to one, and only if there are 3 or
315
 
    # more should they be simplified as one. So we treat the leading 2 slashes
316
 
    # as a special case here by simply removing the first slash, as we consider
317
 
    # that breaking POSIX compatibility for this obscure feature is acceptable.
318
 
    # This is not a paranoid precaution, as we notably get paths like this when
319
 
    # the repo is hosted at the root of the filesystem, i.e. in "/".    
320
 
    if path.startswith('//'):
321
 
        path = path[1:]
322
 
    return path
323
 
 
324
 
 
325
 
def _posix_path_from_environ(key):
326
 
    """Get unicode path from `key` in environment or None if not present
327
 
 
328
 
    Note that posix systems use arbitrary byte strings for filesystem objects,
329
 
    so a path that raises BadFilenameEncoding here may still be accessible.
330
 
    """
331
 
    val = os.environ.get(key, None)
332
 
    if val is None:
333
 
        return val
334
 
    try:
335
 
        return val.decode(_fs_enc)
336
 
    except UnicodeDecodeError:
337
 
        # GZ 2011-12-12:Ideally want to include `key` in the exception message
338
 
        raise errors.BadFilenameEncoding(val, _fs_enc)
339
 
 
340
 
 
341
 
def _posix_getuser_unicode():
342
 
    """Get username from environment or password database as unicode"""
343
 
    name = getpass.getuser()
344
 
    user_encoding = get_user_encoding()
345
 
    try:
346
 
        return name.decode(user_encoding)
347
 
    except UnicodeDecodeError:
348
 
        raise errors.BzrError("Encoding of username %r is unsupported by %s "
349
 
            "application locale." % (name, user_encoding))
350
 
 
351
 
 
352
297
def _win32_fixdrive(path):
353
298
    """Force drive letters to be consistent.
354
299
 
358
303
    running python.exe under cmd.exe return capital C:\\
359
304
    running win32 python inside a cygwin shell returns lowercase c:\\
360
305
    """
361
 
    drive, path = ntpath.splitdrive(path)
 
306
    drive, path = _nt_splitdrive(path)
362
307
    return drive.upper() + path
363
308
 
364
309
 
365
310
def _win32_abspath(path):
366
 
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
367
 
    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('\\', '/'))
368
313
 
369
314
 
370
315
def _win98_abspath(path):
381
326
    #   /path       => C:/path
382
327
    path = unicode(path)
383
328
    # check for absolute path
384
 
    drive = ntpath.splitdrive(path)[0]
 
329
    drive = _nt_splitdrive(path)[0]
385
330
    if drive == '' and path[:2] not in('//','\\\\'):
386
331
        cwd = os.getcwdu()
387
332
        # we cannot simply os.path.join cwd and path
388
333
        # because os.path.join('C:','/path') produce '/path'
389
334
        # and this is incorrect
390
335
        if path[:1] in ('/','\\'):
391
 
            cwd = ntpath.splitdrive(cwd)[0]
 
336
            cwd = _nt_splitdrive(cwd)[0]
392
337
            path = path[1:]
393
338
        path = cwd + '\\' + path
394
 
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
 
339
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
395
340
 
396
341
 
397
342
def _win32_realpath(path):
398
 
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
399
 
    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('\\', '/'))
400
345
 
401
346
 
402
347
def _win32_pathjoin(*args):
403
 
    return ntpath.join(*args).replace('\\', '/')
 
348
    return _nt_join(*args).replace('\\', '/')
404
349
 
405
350
 
406
351
def _win32_normpath(path):
407
 
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
 
352
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
408
353
 
409
354
 
410
355
def _win32_getcwd():
415
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
416
361
 
417
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
 
418
371
def _win32_rename(old, new):
419
372
    """We expect to be able to atomically replace 'new' with old.
420
373
 
422
375
    and then deleted.
423
376
    """
424
377
    try:
425
 
        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)
426
379
    except OSError, e:
427
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
428
381
            # If we try to rename a non-existant file onto cwd, we get
433
386
        raise
434
387
 
435
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
 
436
399
def _mac_getcwd():
437
400
    return unicodedata.normalize('NFC', os.getcwdu())
438
401
 
442
405
abspath = _posix_abspath
443
406
realpath = _posix_realpath
444
407
pathjoin = os.path.join
445
 
normpath = _posix_normpath
446
 
path_from_environ = _posix_path_from_environ
447
 
getuser_unicode = _posix_getuser_unicode
 
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
448
410
getcwd = os.getcwdu
449
 
rename = os.rename
450
411
dirname = os.path.dirname
451
412
basename = os.path.basename
452
413
split = os.path.split
453
414
splitext = os.path.splitext
454
 
# These were already lazily imported into local scope
 
415
# These were already imported into local scope
455
416
# mkdtemp = tempfile.mkdtemp
456
417
# rmtree = shutil.rmtree
457
 
lstat = os.lstat
458
 
fstat = os.fstat
459
 
 
460
 
def wrap_stat(st):
461
 
    return st
462
 
 
463
418
 
464
419
MIN_ABS_PATHLENGTH = 1
465
420
 
475
430
    getcwd = _win32_getcwd
476
431
    mkdtemp = _win32_mkdtemp
477
432
    rename = _win32_rename
478
 
    try:
479
 
        from bzrlib import _walkdirs_win32
480
 
    except ImportError:
481
 
        pass
482
 
    else:
483
 
        lstat = _walkdirs_win32.lstat
484
 
        fstat = _walkdirs_win32.fstat
485
 
        wrap_stat = _walkdirs_win32.wrap_stat
486
433
 
487
434
    MIN_ABS_PATHLENGTH = 3
488
435
 
506
453
    f = win32utils.get_unicode_argv     # special function or None
507
454
    if f is not None:
508
455
        get_unicode_argv = f
509
 
    path_from_environ = win32utils.get_environ_unicode
510
 
    getuser_unicode = win32utils.get_user_name
511
456
 
512
457
elif sys.platform == 'darwin':
513
458
    getcwd = _mac_getcwd
514
459
 
515
460
 
516
 
def get_terminal_encoding(trace=False):
 
461
def get_terminal_encoding():
517
462
    """Find the best encoding for printing to the screen.
518
463
 
519
464
    This attempts to check both sys.stdout and sys.stdin to see
525
470
 
526
471
    On my standard US Windows XP, the preferred encoding is
527
472
    cp1252, but the console is cp437
528
 
 
529
 
    :param trace: If True trace the selected encoding via mutter().
530
473
    """
531
474
    from bzrlib.trace import mutter
532
475
    output_encoding = getattr(sys.stdout, 'encoding', None)
534
477
        input_encoding = getattr(sys.stdin, 'encoding', None)
535
478
        if not input_encoding:
536
479
            output_encoding = get_user_encoding()
537
 
            if trace:
538
 
                mutter('encoding stdout as osutils.get_user_encoding() %r',
 
480
            mutter('encoding stdout as osutils.get_user_encoding() %r',
539
481
                   output_encoding)
540
482
        else:
541
483
            output_encoding = input_encoding
542
 
            if trace:
543
 
                mutter('encoding stdout as sys.stdin encoding %r',
544
 
                    output_encoding)
 
484
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
545
485
    else:
546
 
        if trace:
547
 
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
486
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
548
487
    if output_encoding == 'cp0':
549
488
        # invalid encoding (cp0 means 'no codepage' on Windows)
550
489
        output_encoding = get_user_encoding()
551
 
        if trace:
552
 
            mutter('cp0 is invalid encoding.'
 
490
        mutter('cp0 is invalid encoding.'
553
491
               ' encoding stdout as osutils.get_user_encoding() %r',
554
492
               output_encoding)
555
493
    # check encoding
581
519
def isdir(f):
582
520
    """True if f is an accessible directory."""
583
521
    try:
584
 
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
 
522
        return S_ISDIR(os.lstat(f)[ST_MODE])
585
523
    except OSError:
586
524
        return False
587
525
 
589
527
def isfile(f):
590
528
    """True if f is a regular file."""
591
529
    try:
592
 
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
 
530
        return S_ISREG(os.lstat(f)[ST_MODE])
593
531
    except OSError:
594
532
        return False
595
533
 
596
534
def islink(f):
597
535
    """True if f is a symlink."""
598
536
    try:
599
 
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
 
537
        return S_ISLNK(os.lstat(f)[ST_MODE])
600
538
    except OSError:
601
539
        return False
602
540
 
942
880
 
943
881
def filesize(f):
944
882
    """Return size of given open file."""
945
 
    return os.fstat(f.fileno())[stat.ST_SIZE]
 
883
    return os.fstat(f.fileno())[ST_SIZE]
946
884
 
947
885
 
948
886
# Define rand_bytes based on platform.
993
931
    rps = []
994
932
    for f in ps:
995
933
        if f == '..':
996
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
934
            raise errors.BzrError("sorry, %r not allowed in path" % f)
997
935
        elif (f == '.') or (f == ''):
998
936
            pass
999
937
        else:
1004
942
def joinpath(p):
1005
943
    for f in p:
1006
944
        if (f == '..') or (f is None) or (f == ''):
1007
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
945
            raise errors.BzrError("sorry, %r not allowed in path" % f)
1008
946
    return pathjoin(*p)
1009
947
 
1010
948
 
1011
949
def parent_directories(filename):
1012
950
    """Return the list of parent directories, deepest first.
1013
 
 
 
951
    
1014
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
1015
953
    """
1016
954
    parents = []
1040
978
    # NB: This docstring is just an example, not a doctest, because doctest
1041
979
    # currently can't cope with the use of lazy imports in this namespace --
1042
980
    # mbp 20090729
1043
 
 
 
981
    
1044
982
    # This currently doesn't report the failure at the time it occurs, because
1045
983
    # they tend to happen very early in startup when we can't check config
1046
984
    # files etc, and also we want to report all failures but not spam the user
1047
985
    # with 10 warnings.
 
986
    from bzrlib import trace
1048
987
    exception_str = str(exception)
1049
988
    if exception_str not in _extension_load_failures:
1050
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
1054
993
def report_extension_load_failures():
1055
994
    if not _extension_load_failures:
1056
995
        return
1057
 
    if config.GlobalStack().get('ignore_missing_extensions'):
 
996
    from bzrlib.config import GlobalConfig
 
997
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
1058
998
        return
1059
999
    # the warnings framework should by default show this only once
1060
1000
    from bzrlib.trace import warning
1114
1054
 
1115
1055
 
1116
1056
def delete_any(path):
1117
 
    """Delete a file, symlink or directory.
1118
 
 
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
1119
1059
    Will delete even if readonly.
1120
1060
    """
1121
1061
    try:
1222
1162
 
1223
1163
    if len(base) < MIN_ABS_PATHLENGTH:
1224
1164
        # must have space for e.g. a drive letter
1225
 
        raise ValueError(gettext('%r is too short to calculate a relative path')
 
1165
        raise ValueError('%r is too short to calculate a relative path'
1226
1166
            % (base,))
1227
1167
 
1228
1168
    rp = abspath(path)
1310
1250
    # but for now, we haven't optimized...
1311
1251
    return [canonical_relpath(base, p) for p in paths]
1312
1252
 
1313
 
 
1314
 
def decode_filename(filename):
1315
 
    """Decode the filename using the filesystem encoding
1316
 
 
1317
 
    If it is unicode, it is returned.
1318
 
    Otherwise it is decoded from the the filesystem's encoding. If decoding
1319
 
    fails, a errors.BadFilenameEncoding exception is raised.
1320
 
    """
1321
 
    if type(filename) is unicode:
1322
 
        return filename
1323
 
    try:
1324
 
        return filename.decode(_fs_enc)
1325
 
    except UnicodeDecodeError:
1326
 
        raise errors.BadFilenameEncoding(filename, _fs_enc)
1327
 
 
1328
 
 
1329
1253
def safe_unicode(unicode_or_utf8_string):
1330
1254
    """Coerce unicode_or_utf8_string into unicode.
1331
1255
 
1414
1338
def normalizes_filenames():
1415
1339
    """Return True if this platform normalizes unicode filenames.
1416
1340
 
1417
 
    Only Mac OSX.
 
1341
    Mac OSX does, Windows/Linux do not.
1418
1342
    """
1419
1343
    return _platform_normalizes_filenames
1420
1344
 
1425
1349
    On platforms where the system normalizes filenames (Mac OSX),
1426
1350
    you can access a file by any path which will normalize correctly.
1427
1351
    On platforms where the system does not normalize filenames
1428
 
    (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.
1429
1353
 
1430
1354
    Internally, bzr only supports NFC normalization, since that is
1431
1355
    the standard for XML documents.
1493
1417
terminal_width() returns None.
1494
1418
"""
1495
1419
 
1496
 
# Keep some state so that terminal_width can detect if _terminal_size has
1497
 
# returned a different size since the process started.  See docstring and
1498
 
# comments of terminal_width for details.
1499
 
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1500
 
_terminal_size_state = 'no_data'
1501
 
_first_terminal_size = None
1502
1420
 
1503
1421
def terminal_width():
1504
1422
    """Return terminal width.
1508
1426
    The rules are:
1509
1427
    - if BZR_COLUMNS is set, returns its value
1510
1428
    - if there is no controlling terminal, returns None
1511
 
    - query the OS, if the queried size has changed since the last query,
1512
 
      return its value,
1513
1429
    - if COLUMNS is set, returns its value,
1514
 
    - if the OS has a value (even though it's never changed), return its value.
1515
1430
 
1516
1431
    From there, we need to query the OS to get the size of the controlling
1517
1432
    terminal.
1518
1433
 
1519
 
    On Unices we query the OS by:
 
1434
    Unices:
1520
1435
    - get termios.TIOCGWINSZ
1521
1436
    - if an error occurs or a negative value is obtained, returns None
1522
1437
 
1523
 
    On Windows we query the OS by:
 
1438
    Windows:
 
1439
    
1524
1440
    - win32utils.get_console_size() decides,
1525
1441
    - returns None on error (provided default value)
1526
1442
    """
1527
 
    # Note to implementors: if changing the rules for determining the width,
1528
 
    # make sure you've considered the behaviour in these cases:
1529
 
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1530
 
    #  - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1531
 
    #    0,0.
1532
 
    #  - (add more interesting cases here, if you find any)
1533
 
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1534
 
    # but we don't want to register a signal handler because it is impossible
1535
 
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
1536
 
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
1537
 
    # time so we can notice if the reported size has changed, which should have
1538
 
    # a similar effect.
1539
1443
 
1540
1444
    # If BZR_COLUMNS is set, take it, user is always right
1541
 
    # Except if they specified 0 in which case, impose no limit here
1542
1445
    try:
1543
 
        width = int(os.environ['BZR_COLUMNS'])
 
1446
        return int(os.environ['BZR_COLUMNS'])
1544
1447
    except (KeyError, ValueError):
1545
 
        width = None
1546
 
    if width is not None:
1547
 
        if width > 0:
1548
 
            return width
1549
 
        else:
1550
 
            return None
 
1448
        pass
1551
1449
 
1552
1450
    isatty = getattr(sys.stdout, 'isatty', None)
1553
 
    if isatty is None or not isatty():
 
1451
    if  isatty is None or not isatty():
1554
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
1555
1453
        return None
1556
1454
 
1557
 
    # Query the OS
1558
 
    width, height = os_size = _terminal_size(None, None)
1559
 
    global _first_terminal_size, _terminal_size_state
1560
 
    if _terminal_size_state == 'no_data':
1561
 
        _first_terminal_size = os_size
1562
 
        _terminal_size_state = 'unchanged'
1563
 
    elif (_terminal_size_state == 'unchanged' and
1564
 
          _first_terminal_size != os_size):
1565
 
        _terminal_size_state = 'changed'
1566
 
 
1567
 
    # If the OS claims to know how wide the terminal is, and this value has
1568
 
    # ever changed, use that.
1569
 
    if _terminal_size_state == 'changed':
1570
 
        if width is not None and width > 0:
1571
 
            return width
1572
 
 
1573
 
    # 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))
1574
1458
    try:
1575
1459
        return int(os.environ['COLUMNS'])
1576
1460
    except (KeyError, ValueError):
1577
1461
        pass
1578
1462
 
1579
 
    # Finally, use an unchanged size from the OS, if we have one.
1580
 
    if _terminal_size_state == 'unchanged':
1581
 
        if width is not None and width > 0:
1582
 
            return width
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
1583
1467
 
1584
 
    # The width could not be determined.
1585
 
    return None
 
1468
    return width
1586
1469
 
1587
1470
 
1588
1471
def _win32_terminal_size(width, height):
1615
1498
    _terminal_size = _ioctl_terminal_size
1616
1499
 
1617
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
 
1618
1526
def supports_executable():
1619
1527
    return sys.platform != "win32"
1620
1528
 
1743
1651
        dirblock = []
1744
1652
        append = dirblock.append
1745
1653
        try:
1746
 
            names = sorted(map(decode_filename, _listdir(top)))
 
1654
            names = sorted(_listdir(top))
1747
1655
        except OSError, e:
1748
1656
            if not _is_error_enotdir(e):
1749
1657
                raise
1803
1711
    """
1804
1712
    global _selected_dir_reader
1805
1713
    if _selected_dir_reader is None:
 
1714
        fs_encoding = _fs_enc.upper()
1806
1715
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
1807
1716
            # Win98 doesn't have unicode apis like FindFirstFileW
1808
1717
            # TODO: We possibly could support Win98 by falling back to the
1814
1723
                _selected_dir_reader = Win32ReadDir()
1815
1724
            except ImportError:
1816
1725
                pass
1817
 
        elif _fs_enc in ('utf-8', 'ascii'):
 
1726
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1727
            # ANSI_X3.4-1968 is a form of ASCII
1818
1728
            try:
1819
1729
                from bzrlib._readdir_pyx import UTF8DirReader
1820
1730
                _selected_dir_reader = UTF8DirReader()
1955
1865
        s = os.stat(src)
1956
1866
        chown(dst, s.st_uid, s.st_gid)
1957
1867
    except OSError, e:
1958
 
        trace.warning(
1959
 
            'Unable to copy ownership from "%s" to "%s". '
1960
 
            'You may want to set it manually.', src, dst)
1961
 
        trace.log_exception_quietly()
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1962
1869
 
1963
1870
 
1964
1871
def path_prefix_key(path):
2052
1959
    return user_encoding
2053
1960
 
2054
1961
 
2055
 
def get_diff_header_encoding():
2056
 
    return get_terminal_encoding()
2057
 
 
2058
 
 
2059
 
_message_encoding = None
2060
 
 
2061
 
 
2062
 
def get_message_encoding():
2063
 
    """Return the encoding used for messages
2064
 
 
2065
 
    While the message encoding is a general setting it should usually only be
2066
 
    needed for decoding system error strings such as from OSError instances.
2067
 
    """
2068
 
    global _message_encoding
2069
 
    if _message_encoding is None:
2070
 
        if os.name == "posix":
2071
 
            import locale
2072
 
            # This is a process-global setting that can change, but should in
2073
 
            # general just get set once at process startup then be constant.
2074
 
            _message_encoding = locale.getlocale(locale.LC_MESSAGES)[1]
2075
 
        else:
2076
 
            # On windows want the result of GetACP() which this boils down to.
2077
 
            _message_encoding = get_user_encoding()
2078
 
    return _message_encoding or "ascii"
2079
 
        
2080
 
 
2081
1962
def get_host_name():
2082
1963
    """Return the current unicode host name.
2083
1964
 
2098
1979
# data at once.
2099
1980
MAX_SOCKET_CHUNK = 64 * 1024
2100
1981
 
2101
 
_end_of_stream_errors = [errno.ECONNRESET]
2102
 
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2103
 
    _eno = getattr(errno, _eno, None)
2104
 
    if _eno is not None:
2105
 
        _end_of_stream_errors.append(_eno)
2106
 
del _eno
2107
 
 
2108
 
 
2109
1982
def read_bytes_from_socket(sock, report_activity=None,
2110
1983
        max_read_size=MAX_SOCKET_CHUNK):
2111
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
2119
1992
            bytes = sock.recv(max_read_size)
2120
1993
        except socket.error, e:
2121
1994
            eno = e.args[0]
2122
 
            if eno in _end_of_stream_errors:
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
2123
1996
                # The connection was closed by the other side.  Callers expect
2124
1997
                # an empty string to signal end-of-stream.
2125
1998
                return ""
2154
2027
 
2155
2028
def send_all(sock, bytes, report_activity=None):
2156
2029
    """Send all bytes on a socket.
2157
 
 
 
2030
 
2158
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
2159
2032
    some platforms, and catches EINTR which may be thrown if the send is
2160
2033
    interrupted by a signal.
2161
2034
 
2162
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
2163
2036
    and provides activity reporting.
2164
 
 
 
2037
 
2165
2038
    :param report_activity: Call this as bytes are read, see
2166
2039
        Transport._report_activity
2167
2040
    """
2178
2051
            report_activity(sent, 'write')
2179
2052
 
2180
2053
 
2181
 
def connect_socket(address):
2182
 
    # Slight variation of the socket.create_connection() function (provided by
2183
 
    # python-2.6) that can fail if getaddrinfo returns an empty list. We also
2184
 
    # provide it for previous python versions. Also, we don't use the timeout
2185
 
    # parameter (provided by the python implementation) so we don't implement
2186
 
    # it either).
2187
 
    err = socket.error('getaddrinfo returns an empty list')
2188
 
    host, port = address
2189
 
    for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
2190
 
        af, socktype, proto, canonname, sa = res
2191
 
        sock = None
2192
 
        try:
2193
 
            sock = socket.socket(af, socktype, proto)
2194
 
            sock.connect(sa)
2195
 
            return sock
2196
 
 
2197
 
        except socket.error, err:
2198
 
            # 'err' is now the most recent error
2199
 
            if sock is not None:
2200
 
                sock.close()
2201
 
    raise err
2202
 
 
2203
 
 
2204
2054
def dereference_path(path):
2205
2055
    """Determine the real path to a file.
2206
2056
 
2245
2095
    base = dirname(bzrlib.__file__)
2246
2096
    if getattr(sys, 'frozen', None):    # bzr.exe
2247
2097
        base = abspath(pathjoin(base, '..', '..'))
2248
 
    f = file(pathjoin(base, resource_relpath), "rU")
2249
 
    try:
2250
 
        return f.read()
2251
 
    finally:
2252
 
        f.close()
 
2098
    filename = pathjoin(base, resource_relpath)
 
2099
    return open(filename, 'rU').read()
 
2100
 
2253
2101
 
2254
2102
def file_kind_from_stat_mode_thunk(mode):
2255
2103
    global file_kind_from_stat_mode
2266
2114
    return file_kind_from_stat_mode(mode)
2267
2115
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2268
2116
 
2269
 
def file_stat(f, _lstat=os.lstat):
 
2117
 
 
2118
def file_kind(f, _lstat=os.lstat):
2270
2119
    try:
2271
 
        # XXX cache?
2272
 
        return _lstat(f)
 
2120
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2273
2121
    except OSError, e:
2274
2122
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2275
2123
            raise errors.NoSuchFile(f)
2276
2124
        raise
2277
2125
 
2278
 
def file_kind(f, _lstat=os.lstat):
2279
 
    stat_value = file_stat(f, _lstat)
2280
 
    return file_kind_from_stat_mode(stat_value.st_mode)
2281
2126
 
2282
2127
def until_no_eintr(f, *a, **kw):
2283
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2284
 
 
 
2129
    
2285
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
2286
2131
    if EINTR does occur.  This is typically only true for low-level operations
2287
2132
    like os.read.  If in any doubt, don't use this.
2302
2147
            raise
2303
2148
 
2304
2149
 
2305
 
@deprecated_function(deprecated_in((2, 2, 0)))
2306
2150
def re_compile_checked(re_string, flags=0, where=""):
2307
2151
    """Return a compiled re, or raise a sensible error.
2308
2152
 
2318
2162
        re_obj = re.compile(re_string, flags)
2319
2163
        re_obj.search("")
2320
2164
        return re_obj
2321
 
    except errors.InvalidPattern, e:
 
2165
    except re.error, e:
2322
2166
        if where:
2323
2167
            where = ' in ' + where
2324
2168
        # despite the name 'error' is a type
2325
 
        raise errors.BzrCommandError('Invalid regular expression%s: %s'
2326
 
            % (where, e.msg))
 
2169
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
2170
            % (where, re_string, e))
2327
2171
 
2328
2172
 
2329
2173
if sys.platform == "win32":
 
2174
    import msvcrt
2330
2175
    def getchar():
2331
 
        import msvcrt
2332
2176
        return msvcrt.getch()
2333
2177
else:
 
2178
    import tty
 
2179
    import termios
2334
2180
    def getchar():
2335
 
        import tty
2336
 
        import termios
2337
2181
        fd = sys.stdin.fileno()
2338
2182
        settings = termios.tcgetattr(fd)
2339
2183
        try:
2343
2187
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2344
2188
        return ch
2345
2189
 
2346
 
if sys.platform.startswith('linux'):
 
2190
 
 
2191
if sys.platform == 'linux2':
2347
2192
    def _local_concurrency():
2348
 
        try:
2349
 
            return os.sysconf('SC_NPROCESSORS_ONLN')
2350
 
        except (ValueError, OSError, AttributeError):
2351
 
            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
2352
2199
elif sys.platform == 'darwin':
2353
2200
    def _local_concurrency():
2354
2201
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2355
2202
                                stdout=subprocess.PIPE).communicate()[0]
2356
 
elif "bsd" in sys.platform:
 
2203
elif sys.platform[0:7] == 'freebsd':
2357
2204
    def _local_concurrency():
2358
2205
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2359
2206
                                stdout=subprocess.PIPE).communicate()[0]
2387
2234
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
2388
2235
    if concurrency is None:
2389
2236
        try:
2390
 
            import multiprocessing
2391
 
            concurrency = multiprocessing.cpu_count()
2392
 
        except (ImportError, NotImplementedError):
2393
 
            # multiprocessing is only available on Python >= 2.6
2394
 
            # and multiprocessing.cpu_count() isn't implemented on all
2395
 
            # platforms
2396
 
            try:
2397
 
                concurrency = _local_concurrency()
2398
 
            except (OSError, IOError):
2399
 
                pass
 
2237
            concurrency = _local_concurrency()
 
2238
        except (OSError, IOError):
 
2239
            pass
2400
2240
    try:
2401
2241
        concurrency = int(concurrency)
2402
2242
    except (TypeError, ValueError):
2423
2263
if sys.platform == 'win32':
2424
2264
    def open_file(filename, mode='r', bufsize=-1):
2425
2265
        """This function is used to override the ``open`` builtin.
2426
 
 
 
2266
        
2427
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
2428
2268
        child processes.  Deleting or renaming a closed file opened with this
2429
2269
        function is not blocking child processes.
2462
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2463
2303
else:
2464
2304
    open_file = open
2465
 
 
2466
 
 
2467
 
def available_backup_name(base, exists):
2468
 
    """Find a non-existing backup file name.
2469
 
 
2470
 
    This will *not* create anything, this only return a 'free' entry.  This
2471
 
    should be used for checking names in a directory below a locked
2472
 
    tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
2473
 
    Leap) and generally discouraged.
2474
 
 
2475
 
    :param base: The base name.
2476
 
 
2477
 
    :param exists: A callable returning True if the path parameter exists.
2478
 
    """
2479
 
    counter = 1
2480
 
    name = "%s.~%d~" % (base, counter)
2481
 
    while exists(name):
2482
 
        counter += 1
2483
 
        name = "%s.~%d~" % (base, counter)
2484
 
    return name
2485
 
 
2486
 
 
2487
 
def set_fd_cloexec(fd):
2488
 
    """Set a Unix file descriptor's FD_CLOEXEC flag.  Do nothing if platform
2489
 
    support for this is not available.
2490
 
    """
2491
 
    try:
2492
 
        import fcntl
2493
 
        old = fcntl.fcntl(fd, fcntl.F_GETFD)
2494
 
        fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
2495
 
    except (ImportError, AttributeError):
2496
 
        # Either the fcntl module or specific constants are not present
2497
 
        pass
2498
 
 
2499
 
 
2500
 
def find_executable_on_path(name):
2501
 
    """Finds an executable on the PATH.
2502
 
    
2503
 
    On Windows, this will try to append each extension in the PATHEXT
2504
 
    environment variable to the name, if it cannot be found with the name
2505
 
    as given.
2506
 
    
2507
 
    :param name: The base name of the executable.
2508
 
    :return: The path to the executable found or None.
2509
 
    """
2510
 
    path = os.environ.get('PATH')
2511
 
    if path is None:
2512
 
        return None
2513
 
    path = path.split(os.pathsep)
2514
 
    if sys.platform == 'win32':
2515
 
        exts = os.environ.get('PATHEXT', '').split(os.pathsep)
2516
 
        exts = [ext.lower() for ext in exts]
2517
 
        base, ext = os.path.splitext(name)
2518
 
        if ext != '':
2519
 
            if ext.lower() not in exts:
2520
 
                return None
2521
 
            name = base
2522
 
            exts = [ext]
2523
 
    else:
2524
 
        exts = ['']
2525
 
    for ext in exts:
2526
 
        for d in path:
2527
 
            f = os.path.join(d, name) + ext
2528
 
            if os.access(f, os.X_OK):
2529
 
                return f
2530
 
    return None
2531
 
 
2532
 
 
2533
 
def _posix_is_local_pid_dead(pid):
2534
 
    """True if pid doesn't correspond to live process on this machine"""
2535
 
    try:
2536
 
        # Special meaning of unix kill: just check if it's there.
2537
 
        os.kill(pid, 0)
2538
 
    except OSError, e:
2539
 
        if e.errno == errno.ESRCH:
2540
 
            # On this machine, and really not found: as sure as we can be
2541
 
            # that it's dead.
2542
 
            return True
2543
 
        elif e.errno == errno.EPERM:
2544
 
            # exists, though not ours
2545
 
            return False
2546
 
        else:
2547
 
            mutter("os.kill(%d, 0) failed: %s" % (pid, e))
2548
 
            # Don't really know.
2549
 
            return False
2550
 
    else:
2551
 
        # Exists and our process: not dead.
2552
 
        return False
2553
 
 
2554
 
if sys.platform == "win32":
2555
 
    is_local_pid_dead = win32utils.is_local_pid_dead
2556
 
else:
2557
 
    is_local_pid_dead = _posix_is_local_pid_dead
2558
 
 
2559
 
 
2560
 
def fdatasync(fileno):
2561
 
    """Flush file contents to disk if possible.
2562
 
    
2563
 
    :param fileno: Integer OS file handle.
2564
 
    :raises TransportNotPossible: If flushing to disk is not possible.
2565
 
    """
2566
 
    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))
2567
 
    if fn is not None:
2568
 
        fn(fileno)
2569
 
 
2570
 
 
2571
 
def ensure_empty_directory_exists(path, exception_class):
2572
 
    """Make sure a local directory exists and is empty.
2573
 
    
2574
 
    If it does not exist, it is created.  If it exists and is not empty, an
2575
 
    instance of exception_class is raised.
2576
 
    """
2577
 
    try:
2578
 
        os.mkdir(path)
2579
 
    except OSError, e:
2580
 
        if e.errno != errno.EEXIST:
2581
 
            raise
2582
 
        if os.listdir(path) != []:
2583
 
            raise exception_class(path)
2584
 
 
2585
 
 
2586
 
def is_environment_error(evalue):
2587
 
    """True if exception instance is due to a process environment issue
2588
 
 
2589
 
    This includes OSError and IOError, but also other errors that come from
2590
 
    the operating system or core libraries but are not subclasses of those.
2591
 
    """
2592
 
    if isinstance(evalue, (EnvironmentError, select.error)):
2593
 
        return True
2594
 
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
2595
 
        return True
2596
 
    return False