← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Vincent Ladeuil
  • Date: 2010-04-23 08:51:52 UTC
  • mfrom: (5131.2.6 support_OO_flag)
  • mto: This revision was merged to the branch mainline in revision 5179.
  • Revision ID: v.ladeuil+lp@free.fr-20100423085152-uoewc1vnkwqhw0pj
Manually assign docstrings to command objects, so that they work with python -OO

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009 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
21
21
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
22
22
import sys
23
23
import time
 
24
import codecs
 
25
import warnings
24
26
 
25
27
from bzrlib.lazy_import import lazy_import
26
28
lazy_import(globals(), """
27
 
import codecs
28
29
from datetime import datetime
29
30
import errno
30
31
from ntpath import (abspath as _nt_abspath,
38
39
from shutil import (
39
40
    rmtree,
40
41
    )
 
42
import signal
 
43
import socket
 
44
import subprocess
41
45
import tempfile
42
46
from tempfile import (
43
47
    mkdtemp,
47
51
from bzrlib import (
48
52
    cache_utf8,
49
53
    errors,
 
54
    trace,
50
55
    win32utils,
51
56
    )
52
57
""")
53
58
 
 
59
from bzrlib.symbol_versioning import (
 
60
    deprecated_function,
 
61
    deprecated_in,
 
62
    )
 
63
 
54
64
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
55
65
# of 2.5
56
66
if sys.version_info < (2, 5):
69
79
from bzrlib import symbol_versioning
70
80
 
71
81
 
 
82
# Cross platform wall-clock time functionality with decent resolution.
 
83
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
 
84
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
 
85
# synchronized with ``time.time()``, this is only meant to be used to find
 
86
# delta times by subtracting from another call to this function.
 
87
timer_func = time.time
 
88
if sys.platform == 'win32':
 
89
    timer_func = time.clock
 
90
 
72
91
# On win32, O_BINARY is used to indicate the file should
73
92
# be opened in binary mode, rather than text mode.
74
93
# On other platforms, O_BINARY doesn't exist, because
75
94
# they always open in binary mode, so it is okay to
76
 
# OR with 0 on those platforms
 
95
# OR with 0 on those platforms.
 
96
# O_NOINHERIT and O_TEXT exists only on win32 too.
77
97
O_BINARY = getattr(os, 'O_BINARY', 0)
 
98
O_TEXT = getattr(os, 'O_TEXT', 0)
 
99
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
 
100
 
 
101
 
 
102
def get_unicode_argv():
 
103
    try:
 
104
        user_encoding = get_user_encoding()
 
105
        return [a.decode(user_encoding) for a in sys.argv[1:]]
 
106
    except UnicodeDecodeError:
 
107
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
108
                                                            "encoding." % a))
78
109
 
79
110
 
80
111
def make_readonly(filename):
97
128
 
98
129
    :param paths: A container (and hence not None) of paths.
99
130
    :return: A set of paths sufficient to include everything in paths via
100
 
        is_inside_any, drawn from the paths parameter.
 
131
        is_inside, drawn from the paths parameter.
101
132
    """
102
 
    search_paths = set()
103
 
    paths = set(paths)
104
 
    for path in paths:
105
 
        other_paths = paths.difference([path])
106
 
        if not is_inside_any(other_paths, path):
107
 
            # this is a top level path, we must check it.
108
 
            search_paths.add(path)
109
 
    return search_paths
 
133
    if len(paths) < 2:
 
134
        return set(paths)
 
135
 
 
136
    def sort_key(path):
 
137
        return path.split('/')
 
138
    sorted_paths = sorted(list(paths), key=sort_key)
 
139
 
 
140
    search_paths = [sorted_paths[0]]
 
141
    for path in sorted_paths[1:]:
 
142
        if not is_inside(search_paths[-1], path):
 
143
            # This path is unique, add it
 
144
            search_paths.append(path)
 
145
 
 
146
    return set(search_paths)
110
147
 
111
148
 
112
149
_QUOTE_RE = None
152
189
    try:
153
190
        return _kind_marker_map[kind]
154
191
    except KeyError:
155
 
        raise errors.BzrError('invalid file kind %r' % kind)
 
192
        # Slightly faster than using .get(, '') when the common case is that
 
193
        # kind will be found
 
194
        return ''
156
195
 
157
196
 
158
197
lexists = getattr(os.path, 'lexists', None)
175
214
    :param old: The old path, to rename from
176
215
    :param new: The new path, to rename to
177
216
    :param rename_func: The potentially non-atomic rename function
178
 
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
217
    :param unlink_func: A way to delete the target file if the full rename
 
218
        succeeds
179
219
    """
180
 
 
181
220
    # sftp rename doesn't allow overwriting, so play tricks:
182
221
    base = os.path.basename(new)
183
222
    dirname = os.path.dirname(new)
184
 
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
223
    # callers use different encodings for the paths so the following MUST
 
224
    # respect that. We rely on python upcasting to unicode if new is unicode
 
225
    # and keeping a str if not.
 
226
    tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
 
227
                                      os.getpid(), rand_chars(10))
185
228
    tmp_name = pathjoin(dirname, tmp_name)
186
229
 
187
230
    # Rename the file out of the way, but keep track if it didn't exist
207
250
    else:
208
251
        file_existed = True
209
252
 
 
253
    failure_exc = None
210
254
    success = False
211
255
    try:
212
256
        try:
218
262
            # source and target may be aliases of each other (e.g. on a
219
263
            # case-insensitive filesystem), so we may have accidentally renamed
220
264
            # source by when we tried to rename target
221
 
            if not (file_existed and e.errno in (None, errno.ENOENT)):
222
 
                raise
 
265
            failure_exc = sys.exc_info()
 
266
            if (file_existed and e.errno in (None, errno.ENOENT)
 
267
                and old.lower() == new.lower()):
 
268
                # source and target are the same file on a case-insensitive
 
269
                # filesystem, so we don't generate an exception
 
270
                failure_exc = None
223
271
    finally:
224
272
        if file_existed:
225
273
            # If the file used to exist, rename it back into place
228
276
                unlink_func(tmp_name)
229
277
            else:
230
278
                rename_func(tmp_name, new)
 
279
    if failure_exc is not None:
 
280
        raise failure_exc[0], failure_exc[1], failure_exc[2]
231
281
 
232
282
 
233
283
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
384
434
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
385
435
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
386
436
        return shutil.rmtree(path, ignore_errors, onerror)
 
437
 
 
438
    f = win32utils.get_unicode_argv     # special function or None
 
439
    if f is not None:
 
440
        get_unicode_argv = f
 
441
 
387
442
elif sys.platform == 'darwin':
388
443
    getcwd = _mac_getcwd
389
444
 
618
673
def sha_file_by_name(fname):
619
674
    """Calculate the SHA1 of a file by reading the full text"""
620
675
    s = sha()
621
 
    f = os.open(fname, os.O_RDONLY | O_BINARY)
 
676
    f = os.open(fname, os.O_RDONLY | O_BINARY | O_NOINHERIT)
622
677
    try:
623
678
        while True:
624
679
            b = os.read(f, 1<<16)
666
721
    return offset.days * 86400 + offset.seconds
667
722
 
668
723
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
 
724
_default_format_by_weekday_num = [wd + " %Y-%m-%d %H:%M:%S" for wd in weekdays]
 
725
 
669
726
 
670
727
def format_date(t, offset=0, timezone='original', date_fmt=None,
671
728
                show_offset=True):
685
742
    date_str = time.strftime(date_fmt, tt)
686
743
    return date_str + offset_str
687
744
 
 
745
 
 
746
# Cache of formatted offset strings
 
747
_offset_cache = {}
 
748
 
 
749
 
 
750
def format_date_with_offset_in_original_timezone(t, offset=0,
 
751
    _cache=_offset_cache):
 
752
    """Return a formatted date string in the original timezone.
 
753
 
 
754
    This routine may be faster then format_date.
 
755
 
 
756
    :param t: Seconds since the epoch.
 
757
    :param offset: Timezone offset in seconds east of utc.
 
758
    """
 
759
    if offset is None:
 
760
        offset = 0
 
761
    tt = time.gmtime(t + offset)
 
762
    date_fmt = _default_format_by_weekday_num[tt[6]]
 
763
    date_str = time.strftime(date_fmt, tt)
 
764
    offset_str = _cache.get(offset, None)
 
765
    if offset_str is None:
 
766
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
767
        _cache[offset] = offset_str
 
768
    return date_str + offset_str
 
769
 
 
770
 
688
771
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
689
772
                      show_offset=True):
690
773
    """Return an unicode date string formatted according to the current locale.
701
784
               _format_date(t, offset, timezone, date_fmt, show_offset)
702
785
    date_str = time.strftime(date_fmt, tt)
703
786
    if not isinstance(date_str, unicode):
704
 
        date_str = date_str.decode(bzrlib.user_encoding, 'replace')
 
787
        date_str = date_str.decode(get_user_encoding(), 'replace')
705
788
    return date_str + offset_str
706
789
 
 
790
 
707
791
def _format_date(t, offset, timezone, date_fmt, show_offset):
708
792
    if timezone == 'utc':
709
793
        tt = time.gmtime(t)
847
931
    return pathjoin(*p)
848
932
 
849
933
 
 
934
def parent_directories(filename):
 
935
    """Return the list of parent directories, deepest first.
 
936
    
 
937
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
 
938
    """
 
939
    parents = []
 
940
    parts = splitpath(dirname(filename))
 
941
    while parts:
 
942
        parents.append(joinpath(parts))
 
943
        parts.pop()
 
944
    return parents
 
945
 
 
946
 
 
947
_extension_load_failures = []
 
948
 
 
949
 
 
950
def failed_to_load_extension(exception):
 
951
    """Handle failing to load a binary extension.
 
952
 
 
953
    This should be called from the ImportError block guarding the attempt to
 
954
    import the native extension.  If this function returns, the pure-Python
 
955
    implementation should be loaded instead::
 
956
 
 
957
    >>> try:
 
958
    >>>     import bzrlib._fictional_extension_pyx
 
959
    >>> except ImportError, e:
 
960
    >>>     bzrlib.osutils.failed_to_load_extension(e)
 
961
    >>>     import bzrlib._fictional_extension_py
 
962
    """
 
963
    # NB: This docstring is just an example, not a doctest, because doctest
 
964
    # currently can't cope with the use of lazy imports in this namespace --
 
965
    # mbp 20090729
 
966
    
 
967
    # This currently doesn't report the failure at the time it occurs, because
 
968
    # they tend to happen very early in startup when we can't check config
 
969
    # files etc, and also we want to report all failures but not spam the user
 
970
    # with 10 warnings.
 
971
    from bzrlib import trace
 
972
    exception_str = str(exception)
 
973
    if exception_str not in _extension_load_failures:
 
974
        trace.mutter("failed to load compiled extension: %s" % exception_str)
 
975
        _extension_load_failures.append(exception_str)
 
976
 
 
977
 
 
978
def report_extension_load_failures():
 
979
    if not _extension_load_failures:
 
980
        return
 
981
    from bzrlib.config import GlobalConfig
 
982
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
983
        return
 
984
    # the warnings framework should by default show this only once
 
985
    from bzrlib.trace import warning
 
986
    warning(
 
987
        "bzr: warning: some compiled extensions could not be loaded; "
 
988
        "see <https://answers.launchpad.net/bzr/+faq/703>")
 
989
    # we no longer show the specific missing extensions here, because it makes
 
990
    # the message too long and scary - see
 
991
    # https://bugs.launchpad.net/bzr/+bug/430529
 
992
 
 
993
 
850
994
try:
851
995
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
852
 
except ImportError:
 
996
except ImportError, e:
 
997
    failed_to_load_extension(e)
853
998
    from bzrlib._chunks_to_lines_py import chunks_to_lines
854
999
 
855
1000
 
893
1038
        shutil.copyfile(src, dest)
894
1039
 
895
1040
 
896
 
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
897
 
# Forgiveness than Permission (EAFP) because:
898
 
# - root can damage a solaris file system by using unlink,
899
 
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
900
 
#   EACCES, OSX: EPERM) when invoked on a directory.
901
1041
def delete_any(path):
902
 
    """Delete a file or directory."""
 
1042
    """Delete a file, symlink or directory.  
 
1043
    
 
1044
    Will delete even if readonly.
 
1045
    """
 
1046
    try:
 
1047
       _delete_file_or_dir(path)
 
1048
    except (OSError, IOError), e:
 
1049
        if e.errno in (errno.EPERM, errno.EACCES):
 
1050
            # make writable and try again
 
1051
            try:
 
1052
                make_writable(path)
 
1053
            except (OSError, IOError):
 
1054
                pass
 
1055
            _delete_file_or_dir(path)
 
1056
        else:
 
1057
            raise
 
1058
 
 
1059
 
 
1060
def _delete_file_or_dir(path):
 
1061
    # Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
1062
    # Forgiveness than Permission (EAFP) because:
 
1063
    # - root can damage a solaris file system by using unlink,
 
1064
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
1065
    #   EACCES, OSX: EPERM) when invoked on a directory.
903
1066
    if isdir(path): # Takes care of symlinks
904
1067
        os.rmdir(path)
905
1068
    else:
925
1088
            and sys.platform not in ('cygwin', 'win32'))
926
1089
 
927
1090
 
 
1091
def readlink(abspath):
 
1092
    """Return a string representing the path to which the symbolic link points.
 
1093
 
 
1094
    :param abspath: The link absolute unicode path.
 
1095
 
 
1096
    This his guaranteed to return the symbolic link in unicode in all python
 
1097
    versions.
 
1098
    """
 
1099
    link = abspath.encode(_fs_enc)
 
1100
    target = os.readlink(link)
 
1101
    target = target.decode(_fs_enc)
 
1102
    return target
 
1103
 
 
1104
 
928
1105
def contains_whitespace(s):
929
1106
    """True if there are any whitespace characters in s."""
930
1107
    # string.whitespace can include '\xa0' in certain locales, because it is
974
1151
 
975
1152
    s = []
976
1153
    head = rp
977
 
    while len(head) >= len(base):
 
1154
    while True:
 
1155
        if len(head) <= len(base) and head != base:
 
1156
            raise errors.PathNotChild(rp, base)
978
1157
        if head == base:
979
1158
            break
980
 
        head, tail = os.path.split(head)
 
1159
        head, tail = split(head)
981
1160
        if tail:
982
 
            s.insert(0, tail)
983
 
    else:
984
 
        raise errors.PathNotChild(rp, base)
 
1161
            s.append(tail)
985
1162
 
986
1163
    if s:
987
 
        return pathjoin(*s)
 
1164
        return pathjoin(*reversed(s))
988
1165
    else:
989
1166
        return ''
990
1167
 
1017
1194
    bit_iter = iter(rel.split('/'))
1018
1195
    for bit in bit_iter:
1019
1196
        lbit = bit.lower()
1020
 
        for look in _listdir(current):
 
1197
        try:
 
1198
            next_entries = _listdir(current)
 
1199
        except OSError: # enoent, eperm, etc
 
1200
            # We can't find this in the filesystem, so just append the
 
1201
            # remaining bits.
 
1202
            current = pathjoin(current, bit, *list(bit_iter))
 
1203
            break
 
1204
        for look in next_entries:
1021
1205
            if lbit == look.lower():
1022
1206
                current = pathjoin(current, look)
1023
1207
                break
1027
1211
            # the target of a move, for example).
1028
1212
            current = pathjoin(current, bit, *list(bit_iter))
1029
1213
            break
1030
 
    return current[len(abs_base)+1:]
 
1214
    return current[len(abs_base):].lstrip('/')
1031
1215
 
1032
1216
# XXX - TODO - we need better detection/integration of case-insensitive
1033
 
# file-systems; Linux often sees FAT32 devices, for example, so could
1034
 
# probably benefit from the same basic support there.  For now though, only
1035
 
# Windows gets that support, and it gets it for *all* file-systems!
1036
 
if sys.platform == "win32":
 
1217
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
 
1218
# filesystems), for example, so could probably benefit from the same basic
 
1219
# support there.  For now though, only Windows and OSX get that support, and
 
1220
# they get it for *all* file-systems!
 
1221
if sys.platform in ('win32', 'darwin'):
1037
1222
    canonical_relpath = _cicp_canonical_relpath
1038
1223
else:
1039
1224
    canonical_relpath = relpath
1051
1236
    """Coerce unicode_or_utf8_string into unicode.
1052
1237
 
1053
1238
    If it is unicode, it is returned.
1054
 
    Otherwise it is decoded from utf-8. If a decoding error
1055
 
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped
1056
 
    as a BzrBadParameter exception.
 
1239
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
 
1240
    wrapped in a BzrBadParameterNotUnicode exception.
1057
1241
    """
1058
1242
    if isinstance(unicode_or_utf8_string, unicode):
1059
1243
        return unicode_or_utf8_string
1172
1356
    normalized_filename = _inaccessible_normalized_filename
1173
1357
 
1174
1358
 
 
1359
def set_signal_handler(signum, handler, restart_syscall=True):
 
1360
    """A wrapper for signal.signal that also calls siginterrupt(signum, False)
 
1361
    on platforms that support that.
 
1362
 
 
1363
    :param restart_syscall: if set, allow syscalls interrupted by a signal to
 
1364
        automatically restart (by calling `signal.siginterrupt(signum,
 
1365
        False)`).  May be ignored if the feature is not available on this
 
1366
        platform or Python version.
 
1367
    """
 
1368
    try:
 
1369
        siginterrupt = signal.siginterrupt
 
1370
    except AttributeError:
 
1371
        # siginterrupt doesn't exist on this platform, or for this version
 
1372
        # of Python.
 
1373
        siginterrupt = lambda signum, flag: None
 
1374
    if restart_syscall:
 
1375
        def sig_handler(*args):
 
1376
            # Python resets the siginterrupt flag when a signal is
 
1377
            # received.  <http://bugs.python.org/issue8354>
 
1378
            # As a workaround for some cases, set it back the way we want it.
 
1379
            siginterrupt(signum, False)
 
1380
            # Now run the handler function passed to set_signal_handler.
 
1381
            handler(*args)
 
1382
    else:
 
1383
        sig_handler = handler
 
1384
    old_handler = signal.signal(signum, sig_handler)
 
1385
    if restart_syscall:
 
1386
        siginterrupt(signum, False)
 
1387
    return old_handler
 
1388
 
 
1389
 
 
1390
default_terminal_width = 80
 
1391
"""The default terminal width for ttys.
 
1392
 
 
1393
This is defined so that higher levels can share a common fallback value when
 
1394
terminal_width() returns None.
 
1395
"""
 
1396
 
 
1397
 
1175
1398
def terminal_width():
1176
 
    """Return estimated terminal width."""
1177
 
    if sys.platform == 'win32':
1178
 
        return win32utils.get_console_size()[0]
1179
 
    width = 0
 
1399
    """Return terminal width.
 
1400
 
 
1401
    None is returned if the width can't established precisely.
 
1402
 
 
1403
    The rules are:
 
1404
    - if BZR_COLUMNS is set, returns its value
 
1405
    - if there is no controlling terminal, returns None
 
1406
    - if COLUMNS is set, returns its value,
 
1407
 
 
1408
    From there, we need to query the OS to get the size of the controlling
 
1409
    terminal.
 
1410
 
 
1411
    Unices:
 
1412
    - get termios.TIOCGWINSZ
 
1413
    - if an error occurs or a negative value is obtained, returns None
 
1414
 
 
1415
    Windows:
 
1416
    
 
1417
    - win32utils.get_console_size() decides,
 
1418
    - returns None on error (provided default value)
 
1419
    """
 
1420
 
 
1421
    # If BZR_COLUMNS is set, take it, user is always right
 
1422
    try:
 
1423
        return int(os.environ['BZR_COLUMNS'])
 
1424
    except (KeyError, ValueError):
 
1425
        pass
 
1426
 
 
1427
    isatty = getattr(sys.stdout, 'isatty', None)
 
1428
    if  isatty is None or not isatty():
 
1429
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
 
1430
        return None
 
1431
 
 
1432
    # If COLUMNS is set, take it, the terminal knows better (even inside a
 
1433
    # given terminal, the application can decide to set COLUMNS to a lower
 
1434
    # value (splitted screen) or a bigger value (scroll bars))
 
1435
    try:
 
1436
        return int(os.environ['COLUMNS'])
 
1437
    except (KeyError, ValueError):
 
1438
        pass
 
1439
 
 
1440
    width, height = _terminal_size(None, None)
 
1441
    if width <= 0:
 
1442
        # Consider invalid values as meaning no width
 
1443
        return None
 
1444
 
 
1445
    return width
 
1446
 
 
1447
 
 
1448
def _win32_terminal_size(width, height):
 
1449
    width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
 
1450
    return width, height
 
1451
 
 
1452
 
 
1453
def _ioctl_terminal_size(width, height):
1180
1454
    try:
1181
1455
        import struct, fcntl, termios
1182
1456
        s = struct.pack('HHHH', 0, 0, 0, 0)
1183
1457
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1184
 
        width = struct.unpack('HHHH', x)[1]
1185
 
    except IOError:
 
1458
        height, width = struct.unpack('HHHH', x)[0:2]
 
1459
    except (IOError, AttributeError):
1186
1460
        pass
1187
 
    if width <= 0:
1188
 
        try:
1189
 
            width = int(os.environ['COLUMNS'])
1190
 
        except:
 
1461
    return width, height
 
1462
 
 
1463
_terminal_size = None
 
1464
"""Returns the terminal size as (width, height).
 
1465
 
 
1466
:param width: Default value for width.
 
1467
:param height: Default value for height.
 
1468
 
 
1469
This is defined specifically for each OS and query the size of the controlling
 
1470
terminal. If any error occurs, the provided default values should be returned.
 
1471
"""
 
1472
if sys.platform == 'win32':
 
1473
    _terminal_size = _win32_terminal_size
 
1474
else:
 
1475
    _terminal_size = _ioctl_terminal_size
 
1476
 
 
1477
 
 
1478
def _terminal_size_changed(signum, frame):
 
1479
    """Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
 
1480
    width, height = _terminal_size(None, None)
 
1481
    if width is not None:
 
1482
        os.environ['COLUMNS'] = str(width)
 
1483
 
 
1484
 
 
1485
_registered_sigwinch = False
 
1486
 
 
1487
def watch_sigwinch():
 
1488
    """Register for SIGWINCH, once and only once."""
 
1489
    global _registered_sigwinch
 
1490
    if not _registered_sigwinch:
 
1491
        if sys.platform == 'win32':
 
1492
            # Martin (gz) mentioned WINDOW_BUFFER_SIZE_RECORD from
 
1493
            # ReadConsoleInput but I've no idea how to plug that in
 
1494
            # the current design -- vila 20091216
1191
1495
            pass
1192
 
    if width <= 0:
1193
 
        width = 80
1194
 
 
1195
 
    return width
 
1496
        else:
 
1497
            set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
 
1498
        _registered_sigwinch = True
1196
1499
 
1197
1500
 
1198
1501
def supports_executable():
1392
1695
            #       for win98 anyway.
1393
1696
            try:
1394
1697
                from bzrlib._walkdirs_win32 import Win32ReadDir
1395
 
            except ImportError:
1396
 
                _selected_dir_reader = UnicodeDirReader()
1397
 
            else:
1398
1698
                _selected_dir_reader = Win32ReadDir()
1399
 
        elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1699
            except ImportError:
 
1700
                pass
 
1701
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1400
1702
            # ANSI_X3.4-1968 is a form of ASCII
1401
 
            _selected_dir_reader = UnicodeDirReader()
1402
 
        else:
1403
1703
            try:
1404
1704
                from bzrlib._readdir_pyx import UTF8DirReader
1405
 
            except ImportError:
1406
 
                # No optimised code path
1407
 
                _selected_dir_reader = UnicodeDirReader()
1408
 
            else:
1409
1705
                _selected_dir_reader = UTF8DirReader()
 
1706
            except ImportError, e:
 
1707
                failed_to_load_extension(e)
 
1708
                pass
 
1709
 
 
1710
    if _selected_dir_reader is None:
 
1711
        # Fallback to the python version
 
1712
        _selected_dir_reader = UnicodeDirReader()
 
1713
 
1410
1714
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1411
1715
    # But we don't actually uses 1-3 in pending, so set them to None
1412
1716
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1517
1821
            real_handlers[kind](abspath, relpath)
1518
1822
 
1519
1823
 
 
1824
def copy_ownership(dst, src=None):
 
1825
    """Copy usr/grp ownership from src file/dir to dst file/dir.
 
1826
 
 
1827
    If src is None, the containing directory is used as source. If chown
 
1828
    fails, the error is ignored and a warning is printed.
 
1829
    """
 
1830
    chown = getattr(os, 'chown', None)
 
1831
    if chown is None:
 
1832
        return
 
1833
 
 
1834
    if src == None:
 
1835
        src = os.path.dirname(dst)
 
1836
        if src == '':
 
1837
            src = '.'
 
1838
 
 
1839
    try:
 
1840
        s = os.stat(src)
 
1841
        chown(dst, s.st_uid, s.st_gid)
 
1842
    except OSError, e:
 
1843
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
 
1844
 
 
1845
 
 
1846
def mkdir_with_ownership(path, ownership_src=None):
 
1847
    """Create the directory 'path' with specified ownership.
 
1848
 
 
1849
    If ownership_src is given, copies (chown) usr/grp ownership
 
1850
    from 'ownership_src' to 'path'. If ownership_src is None, use the
 
1851
    containing dir ownership.
 
1852
    """
 
1853
    os.mkdir(path)
 
1854
    copy_ownership(path, ownership_src)
 
1855
 
 
1856
 
 
1857
def open_with_ownership(filename, mode='r', bufsize=-1, ownership_src=None):
 
1858
    """Open the file 'filename' with the specified ownership.
 
1859
 
 
1860
    If ownership_src is specified, copy usr/grp ownership from ownership_src
 
1861
    to filename. If ownership_src is None, copy ownership from containing
 
1862
    directory.
 
1863
    Returns the opened file object.
 
1864
    """
 
1865
    f = open(filename, mode, bufsize)
 
1866
    copy_ownership(filename, ownership_src)
 
1867
    return f
 
1868
 
 
1869
 
1520
1870
def path_prefix_key(path):
1521
1871
    """Generate a prefix-order path key for path.
1522
1872
 
1622
1972
        return socket.gethostname().decode(get_user_encoding())
1623
1973
 
1624
1974
 
1625
 
def recv_all(socket, bytes):
 
1975
# We must not read/write any more than 64k at a time from/to a socket so we
 
1976
# don't risk "no buffer space available" errors on some platforms.  Windows in
 
1977
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
 
1978
# data at once.
 
1979
MAX_SOCKET_CHUNK = 64 * 1024
 
1980
 
 
1981
def read_bytes_from_socket(sock, report_activity=None,
 
1982
        max_read_size=MAX_SOCKET_CHUNK):
 
1983
    """Read up to max_read_size of bytes from sock and notify of progress.
 
1984
 
 
1985
    Translates "Connection reset by peer" into file-like EOF (return an
 
1986
    empty string rather than raise an error), and repeats the recv if
 
1987
    interrupted by a signal.
 
1988
    """
 
1989
    while 1:
 
1990
        try:
 
1991
            bytes = sock.recv(max_read_size)
 
1992
        except socket.error, e:
 
1993
            eno = e.args[0]
 
1994
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
 
1995
                # The connection was closed by the other side.  Callers expect
 
1996
                # an empty string to signal end-of-stream.
 
1997
                return ""
 
1998
            elif eno == errno.EINTR:
 
1999
                # Retry the interrupted recv.
 
2000
                continue
 
2001
            raise
 
2002
        else:
 
2003
            if report_activity is not None:
 
2004
                report_activity(len(bytes), 'read')
 
2005
            return bytes
 
2006
 
 
2007
 
 
2008
def recv_all(socket, count):
1626
2009
    """Receive an exact number of bytes.
1627
2010
 
1628
2011
    Regular Socket.recv() may return less than the requested number of bytes,
1629
 
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
 
2012
    depending on what's in the OS buffer.  MSG_WAITALL is not available
1630
2013
    on all platforms, but this should work everywhere.  This will return
1631
2014
    less than the requested amount if the remote end closes.
1632
2015
 
1633
2016
    This isn't optimized and is intended mostly for use in testing.
1634
2017
    """
1635
2018
    b = ''
1636
 
    while len(b) < bytes:
1637
 
        new = until_no_eintr(socket.recv, bytes - len(b))
 
2019
    while len(b) < count:
 
2020
        new = read_bytes_from_socket(socket, None, count - len(b))
1638
2021
        if new == '':
1639
2022
            break # eof
1640
2023
        b += new
1641
2024
    return b
1642
2025
 
1643
2026
 
1644
 
def send_all(socket, bytes, report_activity=None):
 
2027
def send_all(sock, bytes, report_activity=None):
1645
2028
    """Send all bytes on a socket.
1646
 
 
1647
 
    Regular socket.sendall() can give socket error 10053 on Windows.  This
1648
 
    implementation sends no more than 64k at a time, which avoids this problem.
1649
 
 
 
2029
 
 
2030
    Breaks large blocks in smaller chunks to avoid buffering limitations on
 
2031
    some platforms, and catches EINTR which may be thrown if the send is
 
2032
    interrupted by a signal.
 
2033
 
 
2034
    This is preferred to socket.sendall(), because it avoids portability bugs
 
2035
    and provides activity reporting.
 
2036
 
1650
2037
    :param report_activity: Call this as bytes are read, see
1651
2038
        Transport._report_activity
1652
2039
    """
1653
 
    chunk_size = 2**16
1654
 
    for pos in xrange(0, len(bytes), chunk_size):
1655
 
        block = bytes[pos:pos+chunk_size]
1656
 
        if report_activity is not None:
1657
 
            report_activity(len(block), 'write')
1658
 
        until_no_eintr(socket.sendall, block)
 
2040
    sent_total = 0
 
2041
    byte_count = len(bytes)
 
2042
    while sent_total < byte_count:
 
2043
        try:
 
2044
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
 
2045
        except socket.error, e:
 
2046
            if e.args[0] != errno.EINTR:
 
2047
                raise
 
2048
        else:
 
2049
            sent_total += sent
 
2050
            report_activity(sent, 'write')
1659
2051
 
1660
2052
 
1661
2053
def dereference_path(path):
1712
2104
        try:
1713
2105
            from bzrlib._readdir_pyx import UTF8DirReader
1714
2106
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
1715
 
        except ImportError:
 
2107
        except ImportError, e:
 
2108
            # This is one time where we won't warn that an extension failed to
 
2109
            # load. The extension is never available on Windows anyway.
1716
2110
            from bzrlib._readdir_py import (
1717
2111
                _kind_from_mode as file_kind_from_stat_mode
1718
2112
                )
1730
2124
 
1731
2125
 
1732
2126
def until_no_eintr(f, *a, **kw):
1733
 
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
 
2127
    """Run f(*a, **kw), retrying if an EINTR error occurs.
 
2128
    
 
2129
    WARNING: you must be certain that it is safe to retry the call repeatedly
 
2130
    if EINTR does occur.  This is typically only true for low-level operations
 
2131
    like os.read.  If in any doubt, don't use this.
 
2132
 
 
2133
    Keep in mind that this is not a complete solution to EINTR.  There is
 
2134
    probably code in the Python standard library and other dependencies that
 
2135
    may encounter EINTR if a signal arrives (and there is signal handler for
 
2136
    that signal).  So this function can reduce the impact for IO that bzrlib
 
2137
    directly controls, but it is not a complete solution.
 
2138
    """
1734
2139
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
1735
2140
    while True:
1736
2141
        try:
1740
2145
                continue
1741
2146
            raise
1742
2147
 
 
2148
 
1743
2149
def re_compile_checked(re_string, flags=0, where=""):
1744
2150
    """Return a compiled re, or raise a sensible error.
1745
 
    
 
2151
 
1746
2152
    This should only be used when compiling user-supplied REs.
1747
2153
 
1748
2154
    :param re_string: Text form of regular expression.
1749
2155
    :param flags: eg re.IGNORECASE
1750
 
    :param where: Message explaining to the user the context where 
 
2156
    :param where: Message explaining to the user the context where
1751
2157
        it occurred, eg 'log search filter'.
1752
2158
    """
1753
2159
    # from https://bugs.launchpad.net/bzr/+bug/251352
1779
2185
        finally:
1780
2186
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
1781
2187
        return ch
 
2188
 
 
2189
 
 
2190
if sys.platform == 'linux2':
 
2191
    def _local_concurrency():
 
2192
        concurrency = None
 
2193
        prefix = 'processor'
 
2194
        for line in file('/proc/cpuinfo', 'rb'):
 
2195
            if line.startswith(prefix):
 
2196
                concurrency = int(line[line.find(':')+1:]) + 1
 
2197
        return concurrency
 
2198
elif sys.platform == 'darwin':
 
2199
    def _local_concurrency():
 
2200
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
 
2201
                                stdout=subprocess.PIPE).communicate()[0]
 
2202
elif sys.platform[0:7] == 'freebsd':
 
2203
    def _local_concurrency():
 
2204
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
 
2205
                                stdout=subprocess.PIPE).communicate()[0]
 
2206
elif sys.platform == 'sunos5':
 
2207
    def _local_concurrency():
 
2208
        return subprocess.Popen(['psrinfo', '-p',],
 
2209
                                stdout=subprocess.PIPE).communicate()[0]
 
2210
elif sys.platform == "win32":
 
2211
    def _local_concurrency():
 
2212
        # This appears to return the number of cores.
 
2213
        return os.environ.get('NUMBER_OF_PROCESSORS')
 
2214
else:
 
2215
    def _local_concurrency():
 
2216
        # Who knows ?
 
2217
        return None
 
2218
 
 
2219
 
 
2220
_cached_local_concurrency = None
 
2221
 
 
2222
def local_concurrency(use_cache=True):
 
2223
    """Return how many processes can be run concurrently.
 
2224
 
 
2225
    Rely on platform specific implementations and default to 1 (one) if
 
2226
    anything goes wrong.
 
2227
    """
 
2228
    global _cached_local_concurrency
 
2229
 
 
2230
    if _cached_local_concurrency is not None and use_cache:
 
2231
        return _cached_local_concurrency
 
2232
 
 
2233
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
 
2234
    if concurrency is None:
 
2235
        try:
 
2236
            concurrency = _local_concurrency()
 
2237
        except (OSError, IOError):
 
2238
            pass
 
2239
    try:
 
2240
        concurrency = int(concurrency)
 
2241
    except (TypeError, ValueError):
 
2242
        concurrency = 1
 
2243
    if use_cache:
 
2244
        _cached_concurrency = concurrency
 
2245
    return concurrency
 
2246
 
 
2247
 
 
2248
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
 
2249
    """A stream writer that doesn't decode str arguments."""
 
2250
 
 
2251
    def __init__(self, encode, stream, errors='strict'):
 
2252
        codecs.StreamWriter.__init__(self, stream, errors)
 
2253
        self.encode = encode
 
2254
 
 
2255
    def write(self, object):
 
2256
        if type(object) is str:
 
2257
            self.stream.write(object)
 
2258
        else:
 
2259
            data, _ = self.encode(object, self.errors)
 
2260
            self.stream.write(data)
 
2261
 
 
2262
if sys.platform == 'win32':
 
2263
    def open_file(filename, mode='r', bufsize=-1):
 
2264
        """This function is used to override the ``open`` builtin.
 
2265
        
 
2266
        But it uses O_NOINHERIT flag so the file handle is not inherited by
 
2267
        child processes.  Deleting or renaming a closed file opened with this
 
2268
        function is not blocking child processes.
 
2269
        """
 
2270
        writing = 'w' in mode
 
2271
        appending = 'a' in mode
 
2272
        updating = '+' in mode
 
2273
        binary = 'b' in mode
 
2274
 
 
2275
        flags = O_NOINHERIT
 
2276
        # see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
 
2277
        # for flags for each modes.
 
2278
        if binary:
 
2279
            flags |= O_BINARY
 
2280
        else:
 
2281
            flags |= O_TEXT
 
2282
 
 
2283
        if writing:
 
2284
            if updating:
 
2285
                flags |= os.O_RDWR
 
2286
            else:
 
2287
                flags |= os.O_WRONLY
 
2288
            flags |= os.O_CREAT | os.O_TRUNC
 
2289
        elif appending:
 
2290
            if updating:
 
2291
                flags |= os.O_RDWR
 
2292
            else:
 
2293
                flags |= os.O_WRONLY
 
2294
            flags |= os.O_CREAT | os.O_APPEND
 
2295
        else: #reading
 
2296
            if updating:
 
2297
                flags |= os.O_RDWR
 
2298
            else:
 
2299
                flags |= os.O_RDONLY
 
2300
 
 
2301
        return os.fdopen(os.open(filename, flags), mode, bufsize)
 
2302
else:
 
2303
    open_file = open