~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2010-05-06 07:48:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506074822-0bsgf2j4h8jx0xkk
Added ``bzrlib.tests.matchers`` as a place to put matchers, along with
our first in-tree matcher. See the module docstring for details.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
17
17
import os
18
18
import re
19
19
import stat
20
 
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
 
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
22
21
import sys
23
22
import time
 
23
import codecs
24
24
 
25
25
from bzrlib.lazy_import import lazy_import
26
26
lazy_import(globals(), """
27
 
import codecs
28
27
from datetime import datetime
29
28
import errno
30
29
from ntpath import (abspath as _nt_abspath,
38
37
from shutil import (
39
38
    rmtree,
40
39
    )
 
40
import socket
 
41
import subprocess
41
42
import tempfile
42
43
from tempfile import (
43
44
    mkdtemp,
47
48
from bzrlib import (
48
49
    cache_utf8,
49
50
    errors,
 
51
    trace,
50
52
    win32utils,
51
53
    )
52
54
""")
53
55
 
 
56
from bzrlib.symbol_versioning import (
 
57
    deprecated_function,
 
58
    deprecated_in,
 
59
    )
 
60
 
54
61
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
55
62
# of 2.5
56
63
if sys.version_info < (2, 5):
69
76
from bzrlib import symbol_versioning
70
77
 
71
78
 
 
79
# Cross platform wall-clock time functionality with decent resolution.
 
80
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
 
81
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
 
82
# synchronized with ``time.time()``, this is only meant to be used to find
 
83
# delta times by subtracting from another call to this function.
 
84
timer_func = time.time
 
85
if sys.platform == 'win32':
 
86
    timer_func = time.clock
 
87
 
72
88
# On win32, O_BINARY is used to indicate the file should
73
89
# be opened in binary mode, rather than text mode.
74
90
# On other platforms, O_BINARY doesn't exist, because
75
91
# they always open in binary mode, so it is okay to
76
 
# OR with 0 on those platforms
 
92
# OR with 0 on those platforms.
 
93
# O_NOINHERIT and O_TEXT exists only on win32 too.
77
94
O_BINARY = getattr(os, 'O_BINARY', 0)
 
95
O_TEXT = getattr(os, 'O_TEXT', 0)
 
96
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
 
97
 
 
98
 
 
99
def get_unicode_argv():
 
100
    try:
 
101
        user_encoding = get_user_encoding()
 
102
        return [a.decode(user_encoding) for a in sys.argv[1:]]
 
103
    except UnicodeDecodeError:
 
104
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
105
                                                            "encoding." % a))
78
106
 
79
107
 
80
108
def make_readonly(filename):
97
125
 
98
126
    :param paths: A container (and hence not None) of paths.
99
127
    :return: A set of paths sufficient to include everything in paths via
100
 
        is_inside_any, drawn from the paths parameter.
 
128
        is_inside, drawn from the paths parameter.
101
129
    """
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
 
130
    if len(paths) < 2:
 
131
        return set(paths)
 
132
 
 
133
    def sort_key(path):
 
134
        return path.split('/')
 
135
    sorted_paths = sorted(list(paths), key=sort_key)
 
136
 
 
137
    search_paths = [sorted_paths[0]]
 
138
    for path in sorted_paths[1:]:
 
139
        if not is_inside(search_paths[-1], path):
 
140
            # This path is unique, add it
 
141
            search_paths.append(path)
 
142
 
 
143
    return set(search_paths)
110
144
 
111
145
 
112
146
_QUOTE_RE = None
152
186
    try:
153
187
        return _kind_marker_map[kind]
154
188
    except KeyError:
155
 
        raise errors.BzrError('invalid file kind %r' % kind)
 
189
        # Slightly faster than using .get(, '') when the common case is that
 
190
        # kind will be found
 
191
        return ''
156
192
 
157
193
 
158
194
lexists = getattr(os.path, 'lexists', None)
175
211
    :param old: The old path, to rename from
176
212
    :param new: The new path, to rename to
177
213
    :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
 
214
    :param unlink_func: A way to delete the target file if the full rename
 
215
        succeeds
179
216
    """
180
 
 
181
217
    # sftp rename doesn't allow overwriting, so play tricks:
182
218
    base = os.path.basename(new)
183
219
    dirname = os.path.dirname(new)
184
 
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
220
    # callers use different encodings for the paths so the following MUST
 
221
    # respect that. We rely on python upcasting to unicode if new is unicode
 
222
    # and keeping a str if not.
 
223
    tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
 
224
                                      os.getpid(), rand_chars(10))
185
225
    tmp_name = pathjoin(dirname, tmp_name)
186
226
 
187
227
    # Rename the file out of the way, but keep track if it didn't exist
207
247
    else:
208
248
        file_existed = True
209
249
 
 
250
    failure_exc = None
210
251
    success = False
211
252
    try:
212
253
        try:
218
259
            # source and target may be aliases of each other (e.g. on a
219
260
            # case-insensitive filesystem), so we may have accidentally renamed
220
261
            # source by when we tried to rename target
221
 
            if not (file_existed and e.errno in (None, errno.ENOENT)):
222
 
                raise
 
262
            failure_exc = sys.exc_info()
 
263
            if (file_existed and e.errno in (None, errno.ENOENT)
 
264
                and old.lower() == new.lower()):
 
265
                # source and target are the same file on a case-insensitive
 
266
                # filesystem, so we don't generate an exception
 
267
                failure_exc = None
223
268
    finally:
224
269
        if file_existed:
225
270
            # If the file used to exist, rename it back into place
228
273
                unlink_func(tmp_name)
229
274
            else:
230
275
                rename_func(tmp_name, new)
 
276
    if failure_exc is not None:
 
277
        raise failure_exc[0], failure_exc[1], failure_exc[2]
231
278
 
232
279
 
233
280
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
313
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
314
361
 
315
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
 
316
371
def _win32_rename(old, new):
317
372
    """We expect to be able to atomically replace 'new' with old.
318
373
 
320
375
    and then deleted.
321
376
    """
322
377
    try:
323
 
        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)
324
379
    except OSError, e:
325
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
326
381
            # If we try to rename a non-existant file onto cwd, we get
331
386
        raise
332
387
 
333
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
 
334
399
def _mac_getcwd():
335
400
    return unicodedata.normalize('NFC', os.getcwdu())
336
401
 
341
406
realpath = _posix_realpath
342
407
pathjoin = os.path.join
343
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
344
410
getcwd = os.getcwdu
345
 
rename = os.rename
346
411
dirname = os.path.dirname
347
412
basename = os.path.basename
348
413
split = os.path.split
384
449
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
385
450
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
386
451
        return shutil.rmtree(path, ignore_errors, onerror)
 
452
 
 
453
    f = win32utils.get_unicode_argv     # special function or None
 
454
    if f is not None:
 
455
        get_unicode_argv = f
 
456
 
387
457
elif sys.platform == 'darwin':
388
458
    getcwd = _mac_getcwd
389
459
 
618
688
def sha_file_by_name(fname):
619
689
    """Calculate the SHA1 of a file by reading the full text"""
620
690
    s = sha()
621
 
    f = os.open(fname, os.O_RDONLY | O_BINARY)
 
691
    f = os.open(fname, os.O_RDONLY | O_BINARY | O_NOINHERIT)
622
692
    try:
623
693
        while True:
624
694
            b = os.read(f, 1<<16)
666
736
    return offset.days * 86400 + offset.seconds
667
737
 
668
738
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
 
739
_default_format_by_weekday_num = [wd + " %Y-%m-%d %H:%M:%S" for wd in weekdays]
 
740
 
669
741
 
670
742
def format_date(t, offset=0, timezone='original', date_fmt=None,
671
743
                show_offset=True):
685
757
    date_str = time.strftime(date_fmt, tt)
686
758
    return date_str + offset_str
687
759
 
 
760
 
 
761
# Cache of formatted offset strings
 
762
_offset_cache = {}
 
763
 
 
764
 
 
765
def format_date_with_offset_in_original_timezone(t, offset=0,
 
766
    _cache=_offset_cache):
 
767
    """Return a formatted date string in the original timezone.
 
768
 
 
769
    This routine may be faster then format_date.
 
770
 
 
771
    :param t: Seconds since the epoch.
 
772
    :param offset: Timezone offset in seconds east of utc.
 
773
    """
 
774
    if offset is None:
 
775
        offset = 0
 
776
    tt = time.gmtime(t + offset)
 
777
    date_fmt = _default_format_by_weekday_num[tt[6]]
 
778
    date_str = time.strftime(date_fmt, tt)
 
779
    offset_str = _cache.get(offset, None)
 
780
    if offset_str is None:
 
781
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
782
        _cache[offset] = offset_str
 
783
    return date_str + offset_str
 
784
 
 
785
 
688
786
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
689
787
                      show_offset=True):
690
788
    """Return an unicode date string formatted according to the current locale.
701
799
               _format_date(t, offset, timezone, date_fmt, show_offset)
702
800
    date_str = time.strftime(date_fmt, tt)
703
801
    if not isinstance(date_str, unicode):
704
 
        date_str = date_str.decode(bzrlib.user_encoding, 'replace')
 
802
        date_str = date_str.decode(get_user_encoding(), 'replace')
705
803
    return date_str + offset_str
706
804
 
 
805
 
707
806
def _format_date(t, offset, timezone, date_fmt, show_offset):
708
807
    if timezone == 'utc':
709
808
        tt = time.gmtime(t)
847
946
    return pathjoin(*p)
848
947
 
849
948
 
 
949
def parent_directories(filename):
 
950
    """Return the list of parent directories, deepest first.
 
951
    
 
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
 
953
    """
 
954
    parents = []
 
955
    parts = splitpath(dirname(filename))
 
956
    while parts:
 
957
        parents.append(joinpath(parts))
 
958
        parts.pop()
 
959
    return parents
 
960
 
 
961
 
 
962
_extension_load_failures = []
 
963
 
 
964
 
 
965
def failed_to_load_extension(exception):
 
966
    """Handle failing to load a binary extension.
 
967
 
 
968
    This should be called from the ImportError block guarding the attempt to
 
969
    import the native extension.  If this function returns, the pure-Python
 
970
    implementation should be loaded instead::
 
971
 
 
972
    >>> try:
 
973
    >>>     import bzrlib._fictional_extension_pyx
 
974
    >>> except ImportError, e:
 
975
    >>>     bzrlib.osutils.failed_to_load_extension(e)
 
976
    >>>     import bzrlib._fictional_extension_py
 
977
    """
 
978
    # NB: This docstring is just an example, not a doctest, because doctest
 
979
    # currently can't cope with the use of lazy imports in this namespace --
 
980
    # mbp 20090729
 
981
    
 
982
    # This currently doesn't report the failure at the time it occurs, because
 
983
    # they tend to happen very early in startup when we can't check config
 
984
    # files etc, and also we want to report all failures but not spam the user
 
985
    # with 10 warnings.
 
986
    from bzrlib import trace
 
987
    exception_str = str(exception)
 
988
    if exception_str not in _extension_load_failures:
 
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
 
990
        _extension_load_failures.append(exception_str)
 
991
 
 
992
 
 
993
def report_extension_load_failures():
 
994
    if not _extension_load_failures:
 
995
        return
 
996
    from bzrlib.config import GlobalConfig
 
997
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
998
        return
 
999
    # the warnings framework should by default show this only once
 
1000
    from bzrlib.trace import warning
 
1001
    warning(
 
1002
        "bzr: warning: some compiled extensions could not be loaded; "
 
1003
        "see <https://answers.launchpad.net/bzr/+faq/703>")
 
1004
    # we no longer show the specific missing extensions here, because it makes
 
1005
    # the message too long and scary - see
 
1006
    # https://bugs.launchpad.net/bzr/+bug/430529
 
1007
 
 
1008
 
850
1009
try:
851
1010
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
852
 
except ImportError:
 
1011
except ImportError, e:
 
1012
    failed_to_load_extension(e)
853
1013
    from bzrlib._chunks_to_lines_py import chunks_to_lines
854
1014
 
855
1015
 
893
1053
        shutil.copyfile(src, dest)
894
1054
 
895
1055
 
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
1056
def delete_any(path):
902
 
    """Delete a file or directory."""
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
 
1059
    Will delete even if readonly.
 
1060
    """
 
1061
    try:
 
1062
       _delete_file_or_dir(path)
 
1063
    except (OSError, IOError), e:
 
1064
        if e.errno in (errno.EPERM, errno.EACCES):
 
1065
            # make writable and try again
 
1066
            try:
 
1067
                make_writable(path)
 
1068
            except (OSError, IOError):
 
1069
                pass
 
1070
            _delete_file_or_dir(path)
 
1071
        else:
 
1072
            raise
 
1073
 
 
1074
 
 
1075
def _delete_file_or_dir(path):
 
1076
    # Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
1077
    # Forgiveness than Permission (EAFP) because:
 
1078
    # - root can damage a solaris file system by using unlink,
 
1079
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
1080
    #   EACCES, OSX: EPERM) when invoked on a directory.
903
1081
    if isdir(path): # Takes care of symlinks
904
1082
        os.rmdir(path)
905
1083
    else:
925
1103
            and sys.platform not in ('cygwin', 'win32'))
926
1104
 
927
1105
 
 
1106
def readlink(abspath):
 
1107
    """Return a string representing the path to which the symbolic link points.
 
1108
 
 
1109
    :param abspath: The link absolute unicode path.
 
1110
 
 
1111
    This his guaranteed to return the symbolic link in unicode in all python
 
1112
    versions.
 
1113
    """
 
1114
    link = abspath.encode(_fs_enc)
 
1115
    target = os.readlink(link)
 
1116
    target = target.decode(_fs_enc)
 
1117
    return target
 
1118
 
 
1119
 
928
1120
def contains_whitespace(s):
929
1121
    """True if there are any whitespace characters in s."""
930
1122
    # string.whitespace can include '\xa0' in certain locales, because it is
955
1147
 
956
1148
 
957
1149
def relpath(base, path):
958
 
    """Return path relative to base, or raise exception.
 
1150
    """Return path relative to base, or raise PathNotChild exception.
959
1151
 
960
1152
    The path may be either an absolute path or a path relative to the
961
1153
    current working directory.
963
1155
    os.path.commonprefix (python2.4) has a bad bug that it works just
964
1156
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
965
1157
    avoids that problem.
 
1158
 
 
1159
    NOTE: `base` should not have a trailing slash otherwise you'll get
 
1160
    PathNotChild exceptions regardless of `path`.
966
1161
    """
967
1162
 
968
1163
    if len(base) < MIN_ABS_PATHLENGTH:
974
1169
 
975
1170
    s = []
976
1171
    head = rp
977
 
    while len(head) >= len(base):
 
1172
    while True:
 
1173
        if len(head) <= len(base) and head != base:
 
1174
            raise errors.PathNotChild(rp, base)
978
1175
        if head == base:
979
1176
            break
980
 
        head, tail = os.path.split(head)
 
1177
        head, tail = split(head)
981
1178
        if tail:
982
 
            s.insert(0, tail)
983
 
    else:
984
 
        raise errors.PathNotChild(rp, base)
 
1179
            s.append(tail)
985
1180
 
986
1181
    if s:
987
 
        return pathjoin(*s)
 
1182
        return pathjoin(*reversed(s))
988
1183
    else:
989
1184
        return ''
990
1185
 
1017
1212
    bit_iter = iter(rel.split('/'))
1018
1213
    for bit in bit_iter:
1019
1214
        lbit = bit.lower()
1020
 
        for look in _listdir(current):
 
1215
        try:
 
1216
            next_entries = _listdir(current)
 
1217
        except OSError: # enoent, eperm, etc
 
1218
            # We can't find this in the filesystem, so just append the
 
1219
            # remaining bits.
 
1220
            current = pathjoin(current, bit, *list(bit_iter))
 
1221
            break
 
1222
        for look in next_entries:
1021
1223
            if lbit == look.lower():
1022
1224
                current = pathjoin(current, look)
1023
1225
                break
1027
1229
            # the target of a move, for example).
1028
1230
            current = pathjoin(current, bit, *list(bit_iter))
1029
1231
            break
1030
 
    return current[len(abs_base)+1:]
 
1232
    return current[len(abs_base):].lstrip('/')
1031
1233
 
1032
1234
# XXX - TODO - we need better detection/integration of case-insensitive
1033
1235
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1172
1374
    normalized_filename = _inaccessible_normalized_filename
1173
1375
 
1174
1376
 
 
1377
def set_signal_handler(signum, handler, restart_syscall=True):
 
1378
    """A wrapper for signal.signal that also calls siginterrupt(signum, False)
 
1379
    on platforms that support that.
 
1380
 
 
1381
    :param restart_syscall: if set, allow syscalls interrupted by a signal to
 
1382
        automatically restart (by calling `signal.siginterrupt(signum,
 
1383
        False)`).  May be ignored if the feature is not available on this
 
1384
        platform or Python version.
 
1385
    """
 
1386
    try:
 
1387
        import signal
 
1388
        siginterrupt = signal.siginterrupt
 
1389
    except ImportError:
 
1390
        # This python implementation doesn't provide signal support, hence no
 
1391
        # handler exists
 
1392
        return None
 
1393
    except AttributeError:
 
1394
        # siginterrupt doesn't exist on this platform, or for this version
 
1395
        # of Python.
 
1396
        siginterrupt = lambda signum, flag: None
 
1397
    if restart_syscall:
 
1398
        def sig_handler(*args):
 
1399
            # Python resets the siginterrupt flag when a signal is
 
1400
            # received.  <http://bugs.python.org/issue8354>
 
1401
            # As a workaround for some cases, set it back the way we want it.
 
1402
            siginterrupt(signum, False)
 
1403
            # Now run the handler function passed to set_signal_handler.
 
1404
            handler(*args)
 
1405
    else:
 
1406
        sig_handler = handler
 
1407
    old_handler = signal.signal(signum, sig_handler)
 
1408
    if restart_syscall:
 
1409
        siginterrupt(signum, False)
 
1410
    return old_handler
 
1411
 
 
1412
 
 
1413
default_terminal_width = 80
 
1414
"""The default terminal width for ttys.
 
1415
 
 
1416
This is defined so that higher levels can share a common fallback value when
 
1417
terminal_width() returns None.
 
1418
"""
 
1419
 
 
1420
 
1175
1421
def terminal_width():
1176
 
    """Return estimated terminal width."""
1177
 
    if sys.platform == 'win32':
1178
 
        return win32utils.get_console_size()[0]
1179
 
    width = 0
 
1422
    """Return terminal width.
 
1423
 
 
1424
    None is returned if the width can't established precisely.
 
1425
 
 
1426
    The rules are:
 
1427
    - if BZR_COLUMNS is set, returns its value
 
1428
    - if there is no controlling terminal, returns None
 
1429
    - if COLUMNS is set, returns its value,
 
1430
 
 
1431
    From there, we need to query the OS to get the size of the controlling
 
1432
    terminal.
 
1433
 
 
1434
    Unices:
 
1435
    - get termios.TIOCGWINSZ
 
1436
    - if an error occurs or a negative value is obtained, returns None
 
1437
 
 
1438
    Windows:
 
1439
    
 
1440
    - win32utils.get_console_size() decides,
 
1441
    - returns None on error (provided default value)
 
1442
    """
 
1443
 
 
1444
    # If BZR_COLUMNS is set, take it, user is always right
 
1445
    try:
 
1446
        return int(os.environ['BZR_COLUMNS'])
 
1447
    except (KeyError, ValueError):
 
1448
        pass
 
1449
 
 
1450
    isatty = getattr(sys.stdout, 'isatty', None)
 
1451
    if  isatty is None or not isatty():
 
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
 
1453
        return None
 
1454
 
 
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))
 
1458
    try:
 
1459
        return int(os.environ['COLUMNS'])
 
1460
    except (KeyError, ValueError):
 
1461
        pass
 
1462
 
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
 
1467
 
 
1468
    return width
 
1469
 
 
1470
 
 
1471
def _win32_terminal_size(width, height):
 
1472
    width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
 
1473
    return width, height
 
1474
 
 
1475
 
 
1476
def _ioctl_terminal_size(width, height):
1180
1477
    try:
1181
1478
        import struct, fcntl, termios
1182
1479
        s = struct.pack('HHHH', 0, 0, 0, 0)
1183
1480
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1184
 
        width = struct.unpack('HHHH', x)[1]
1185
 
    except IOError:
 
1481
        height, width = struct.unpack('HHHH', x)[0:2]
 
1482
    except (IOError, AttributeError):
1186
1483
        pass
1187
 
    if width <= 0:
 
1484
    return width, height
 
1485
 
 
1486
_terminal_size = None
 
1487
"""Returns the terminal size as (width, height).
 
1488
 
 
1489
:param width: Default value for width.
 
1490
:param height: Default value for height.
 
1491
 
 
1492
This is defined specifically for each OS and query the size of the controlling
 
1493
terminal. If any error occurs, the provided default values should be returned.
 
1494
"""
 
1495
if sys.platform == 'win32':
 
1496
    _terminal_size = _win32_terminal_size
 
1497
else:
 
1498
    _terminal_size = _ioctl_terminal_size
 
1499
 
 
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:
1188
1516
        try:
1189
 
            width = int(os.environ['COLUMNS'])
1190
 
        except:
 
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
1191
1522
            pass
1192
 
    if width <= 0:
1193
 
        width = 80
1194
 
 
1195
 
    return width
 
1523
        _registered_sigwinch = True
1196
1524
 
1197
1525
 
1198
1526
def supports_executable():
1392
1720
            #       for win98 anyway.
1393
1721
            try:
1394
1722
                from bzrlib._walkdirs_win32 import Win32ReadDir
1395
 
            except ImportError:
1396
 
                _selected_dir_reader = UnicodeDirReader()
1397
 
            else:
1398
1723
                _selected_dir_reader = Win32ReadDir()
1399
 
        elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1724
            except ImportError:
 
1725
                pass
 
1726
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1400
1727
            # ANSI_X3.4-1968 is a form of ASCII
1401
 
            _selected_dir_reader = UnicodeDirReader()
1402
 
        else:
1403
1728
            try:
1404
1729
                from bzrlib._readdir_pyx import UTF8DirReader
1405
 
            except ImportError:
1406
 
                # No optimised code path
1407
 
                _selected_dir_reader = UnicodeDirReader()
1408
 
            else:
1409
1730
                _selected_dir_reader = UTF8DirReader()
 
1731
            except ImportError, e:
 
1732
                failed_to_load_extension(e)
 
1733
                pass
 
1734
 
 
1735
    if _selected_dir_reader is None:
 
1736
        # Fallback to the python version
 
1737
        _selected_dir_reader = UnicodeDirReader()
 
1738
 
1410
1739
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1411
1740
    # But we don't actually uses 1-3 in pending, so set them to None
1412
1741
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1517
1846
            real_handlers[kind](abspath, relpath)
1518
1847
 
1519
1848
 
 
1849
def copy_ownership_from_path(dst, src=None):
 
1850
    """Copy usr/grp ownership from src file/dir to dst file/dir.
 
1851
 
 
1852
    If src is None, the containing directory is used as source. If chown
 
1853
    fails, the error is ignored and a warning is printed.
 
1854
    """
 
1855
    chown = getattr(os, 'chown', None)
 
1856
    if chown is None:
 
1857
        return
 
1858
 
 
1859
    if src == None:
 
1860
        src = os.path.dirname(dst)
 
1861
        if src == '':
 
1862
            src = '.'
 
1863
 
 
1864
    try:
 
1865
        s = os.stat(src)
 
1866
        chown(dst, s.st_uid, s.st_gid)
 
1867
    except OSError, e:
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
 
1869
 
 
1870
 
1520
1871
def path_prefix_key(path):
1521
1872
    """Generate a prefix-order path key for path.
1522
1873
 
1622
1973
        return socket.gethostname().decode(get_user_encoding())
1623
1974
 
1624
1975
 
1625
 
def recv_all(socket, bytes):
 
1976
# We must not read/write any more than 64k at a time from/to a socket so we
 
1977
# don't risk "no buffer space available" errors on some platforms.  Windows in
 
1978
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
 
1979
# data at once.
 
1980
MAX_SOCKET_CHUNK = 64 * 1024
 
1981
 
 
1982
def read_bytes_from_socket(sock, report_activity=None,
 
1983
        max_read_size=MAX_SOCKET_CHUNK):
 
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
 
1985
 
 
1986
    Translates "Connection reset by peer" into file-like EOF (return an
 
1987
    empty string rather than raise an error), and repeats the recv if
 
1988
    interrupted by a signal.
 
1989
    """
 
1990
    while 1:
 
1991
        try:
 
1992
            bytes = sock.recv(max_read_size)
 
1993
        except socket.error, e:
 
1994
            eno = e.args[0]
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
 
1996
                # The connection was closed by the other side.  Callers expect
 
1997
                # an empty string to signal end-of-stream.
 
1998
                return ""
 
1999
            elif eno == errno.EINTR:
 
2000
                # Retry the interrupted recv.
 
2001
                continue
 
2002
            raise
 
2003
        else:
 
2004
            if report_activity is not None:
 
2005
                report_activity(len(bytes), 'read')
 
2006
            return bytes
 
2007
 
 
2008
 
 
2009
def recv_all(socket, count):
1626
2010
    """Receive an exact number of bytes.
1627
2011
 
1628
2012
    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
 
2013
    depending on what's in the OS buffer.  MSG_WAITALL is not available
1630
2014
    on all platforms, but this should work everywhere.  This will return
1631
2015
    less than the requested amount if the remote end closes.
1632
2016
 
1633
2017
    This isn't optimized and is intended mostly for use in testing.
1634
2018
    """
1635
2019
    b = ''
1636
 
    while len(b) < bytes:
1637
 
        new = until_no_eintr(socket.recv, bytes - len(b))
 
2020
    while len(b) < count:
 
2021
        new = read_bytes_from_socket(socket, None, count - len(b))
1638
2022
        if new == '':
1639
2023
            break # eof
1640
2024
        b += new
1641
2025
    return b
1642
2026
 
1643
2027
 
1644
 
def send_all(socket, bytes, report_activity=None):
 
2028
def send_all(sock, bytes, report_activity=None):
1645
2029
    """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
 
 
 
2030
 
 
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
 
2032
    some platforms, and catches EINTR which may be thrown if the send is
 
2033
    interrupted by a signal.
 
2034
 
 
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
 
2036
    and provides activity reporting.
 
2037
 
1650
2038
    :param report_activity: Call this as bytes are read, see
1651
2039
        Transport._report_activity
1652
2040
    """
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)
 
2041
    sent_total = 0
 
2042
    byte_count = len(bytes)
 
2043
    while sent_total < byte_count:
 
2044
        try:
 
2045
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
 
2046
        except socket.error, e:
 
2047
            if e.args[0] != errno.EINTR:
 
2048
                raise
 
2049
        else:
 
2050
            sent_total += sent
 
2051
            report_activity(sent, 'write')
1659
2052
 
1660
2053
 
1661
2054
def dereference_path(path):
1712
2105
        try:
1713
2106
            from bzrlib._readdir_pyx import UTF8DirReader
1714
2107
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
1715
 
        except ImportError:
 
2108
        except ImportError, e:
 
2109
            # This is one time where we won't warn that an extension failed to
 
2110
            # load. The extension is never available on Windows anyway.
1716
2111
            from bzrlib._readdir_py import (
1717
2112
                _kind_from_mode as file_kind_from_stat_mode
1718
2113
                )
1730
2125
 
1731
2126
 
1732
2127
def until_no_eintr(f, *a, **kw):
1733
 
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
 
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
 
2129
    
 
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
 
2131
    if EINTR does occur.  This is typically only true for low-level operations
 
2132
    like os.read.  If in any doubt, don't use this.
 
2133
 
 
2134
    Keep in mind that this is not a complete solution to EINTR.  There is
 
2135
    probably code in the Python standard library and other dependencies that
 
2136
    may encounter EINTR if a signal arrives (and there is signal handler for
 
2137
    that signal).  So this function can reduce the impact for IO that bzrlib
 
2138
    directly controls, but it is not a complete solution.
 
2139
    """
1734
2140
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
1735
2141
    while True:
1736
2142
        try:
1740
2146
                continue
1741
2147
            raise
1742
2148
 
 
2149
 
1743
2150
def re_compile_checked(re_string, flags=0, where=""):
1744
2151
    """Return a compiled re, or raise a sensible error.
1745
 
    
 
2152
 
1746
2153
    This should only be used when compiling user-supplied REs.
1747
2154
 
1748
2155
    :param re_string: Text form of regular expression.
1749
2156
    :param flags: eg re.IGNORECASE
1750
 
    :param where: Message explaining to the user the context where 
 
2157
    :param where: Message explaining to the user the context where
1751
2158
        it occurred, eg 'log search filter'.
1752
2159
    """
1753
2160
    # from https://bugs.launchpad.net/bzr/+bug/251352
1779
2186
        finally:
1780
2187
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
1781
2188
        return ch
 
2189
 
 
2190
 
 
2191
if sys.platform == 'linux2':
 
2192
    def _local_concurrency():
 
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
 
2199
elif sys.platform == 'darwin':
 
2200
    def _local_concurrency():
 
2201
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
 
2202
                                stdout=subprocess.PIPE).communicate()[0]
 
2203
elif sys.platform[0:7] == 'freebsd':
 
2204
    def _local_concurrency():
 
2205
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
 
2206
                                stdout=subprocess.PIPE).communicate()[0]
 
2207
elif sys.platform == 'sunos5':
 
2208
    def _local_concurrency():
 
2209
        return subprocess.Popen(['psrinfo', '-p',],
 
2210
                                stdout=subprocess.PIPE).communicate()[0]
 
2211
elif sys.platform == "win32":
 
2212
    def _local_concurrency():
 
2213
        # This appears to return the number of cores.
 
2214
        return os.environ.get('NUMBER_OF_PROCESSORS')
 
2215
else:
 
2216
    def _local_concurrency():
 
2217
        # Who knows ?
 
2218
        return None
 
2219
 
 
2220
 
 
2221
_cached_local_concurrency = None
 
2222
 
 
2223
def local_concurrency(use_cache=True):
 
2224
    """Return how many processes can be run concurrently.
 
2225
 
 
2226
    Rely on platform specific implementations and default to 1 (one) if
 
2227
    anything goes wrong.
 
2228
    """
 
2229
    global _cached_local_concurrency
 
2230
 
 
2231
    if _cached_local_concurrency is not None and use_cache:
 
2232
        return _cached_local_concurrency
 
2233
 
 
2234
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
 
2235
    if concurrency is None:
 
2236
        try:
 
2237
            concurrency = _local_concurrency()
 
2238
        except (OSError, IOError):
 
2239
            pass
 
2240
    try:
 
2241
        concurrency = int(concurrency)
 
2242
    except (TypeError, ValueError):
 
2243
        concurrency = 1
 
2244
    if use_cache:
 
2245
        _cached_concurrency = concurrency
 
2246
    return concurrency
 
2247
 
 
2248
 
 
2249
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
 
2250
    """A stream writer that doesn't decode str arguments."""
 
2251
 
 
2252
    def __init__(self, encode, stream, errors='strict'):
 
2253
        codecs.StreamWriter.__init__(self, stream, errors)
 
2254
        self.encode = encode
 
2255
 
 
2256
    def write(self, object):
 
2257
        if type(object) is str:
 
2258
            self.stream.write(object)
 
2259
        else:
 
2260
            data, _ = self.encode(object, self.errors)
 
2261
            self.stream.write(data)
 
2262
 
 
2263
if sys.platform == 'win32':
 
2264
    def open_file(filename, mode='r', bufsize=-1):
 
2265
        """This function is used to override the ``open`` builtin.
 
2266
        
 
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
 
2268
        child processes.  Deleting or renaming a closed file opened with this
 
2269
        function is not blocking child processes.
 
2270
        """
 
2271
        writing = 'w' in mode
 
2272
        appending = 'a' in mode
 
2273
        updating = '+' in mode
 
2274
        binary = 'b' in mode
 
2275
 
 
2276
        flags = O_NOINHERIT
 
2277
        # see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
 
2278
        # for flags for each modes.
 
2279
        if binary:
 
2280
            flags |= O_BINARY
 
2281
        else:
 
2282
            flags |= O_TEXT
 
2283
 
 
2284
        if writing:
 
2285
            if updating:
 
2286
                flags |= os.O_RDWR
 
2287
            else:
 
2288
                flags |= os.O_WRONLY
 
2289
            flags |= os.O_CREAT | os.O_TRUNC
 
2290
        elif appending:
 
2291
            if updating:
 
2292
                flags |= os.O_RDWR
 
2293
            else:
 
2294
                flags |= os.O_WRONLY
 
2295
            flags |= os.O_CREAT | os.O_APPEND
 
2296
        else: #reading
 
2297
            if updating:
 
2298
                flags |= os.O_RDWR
 
2299
            else:
 
2300
                flags |= os.O_RDONLY
 
2301
 
 
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
 
2303
else:
 
2304
    open_file = open