← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-31 15:43:17 UTC
  • mfrom: (6437.3.28 2.5)
  • mto: (6437.23.1 2.5)
  • mto: This revision was merged to the branch mainline in revision 6458.
  • Revision ID: jelmer@samba.org-20120131154317-y028tz0r9xesvn9p
Merge 2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
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
 
17
19
import errno
18
20
import os
19
21
import re
26
28
lazy_import(globals(), """
27
29
from datetime import datetime
28
30
import getpass
 
31
import locale
29
32
import ntpath
30
33
import posixpath
 
34
import select
31
35
# We need to import both shutil and rmtree as we export the later on posix
32
36
# and need the former on windows
33
37
import shutil
42
46
 
43
47
from bzrlib import (
44
48
    cache_utf8,
 
49
    config,
45
50
    errors,
46
51
    trace,
47
52
    win32utils,
48
53
    )
 
54
from bzrlib.i18n import gettext
49
55
""")
50
56
 
51
57
from bzrlib.symbol_versioning import (
 
58
    DEPRECATED_PARAMETER,
52
59
    deprecated_function,
53
60
    deprecated_in,
 
61
    deprecated_passed,
 
62
    warn as warn_deprecated,
54
63
    )
55
64
 
56
65
from hashlib import (
60
69
 
61
70
 
62
71
import bzrlib
63
 
from bzrlib import symbol_versioning
 
72
from bzrlib import symbol_versioning, _fs_enc
64
73
 
65
74
 
66
75
# Cross platform wall-clock time functionality with decent resolution.
88
97
        user_encoding = get_user_encoding()
89
98
        return [a.decode(user_encoding) for a in sys.argv[1:]]
90
99
    except UnicodeDecodeError:
91
 
        raise errors.BzrError("Parameter %r encoding is unsupported by %s "
92
 
            "application locale." % (a, user_encoding))
 
100
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
 
101
            "application locale.").format(a, user_encoding))
93
102
 
94
103
 
95
104
def make_readonly(filename):
208
217
            if e.errno == errno.ENOENT:
209
218
                return False;
210
219
            else:
211
 
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
 
220
                raise errors.BzrError(gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
212
221
 
213
222
 
214
223
def fancy_rename(old, new, rename_func, unlink_func):
290
299
# choke on a Unicode string containing a relative path if
291
300
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
292
301
# string.
293
 
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
294
302
def _posix_abspath(path):
295
303
    # jam 20060426 rather than encoding to fsencoding
296
304
    # copy posixpath.abspath, but use os.getcwdu instead
318
326
    return path
319
327
 
320
328
 
 
329
def _posix_path_from_environ(key):
 
330
    """Get unicode path from `key` in environment or None if not present
 
331
 
 
332
    Note that posix systems use arbitrary byte strings for filesystem objects,
 
333
    so a path that raises BadFilenameEncoding here may still be accessible.
 
334
    """
 
335
    val = os.environ.get(key, None)
 
336
    if val is None:
 
337
        return val
 
338
    try:
 
339
        return val.decode(_fs_enc)
 
340
    except UnicodeDecodeError:
 
341
        # GZ 2011-12-12:Ideally want to include `key` in the exception message
 
342
        raise errors.BadFilenameEncoding(val, _fs_enc)
 
343
 
 
344
 
 
345
def _posix_getuser_unicode():
 
346
    """Get username from environment or password database as unicode"""
 
347
    name = getpass.getuser()
 
348
    user_encoding = get_user_encoding()
 
349
    try:
 
350
        return name.decode(user_encoding)
 
351
    except UnicodeDecodeError:
 
352
        raise errors.BzrError("Encoding of username %r is unsupported by %s "
 
353
            "application locale." % (name, user_encoding))
 
354
 
 
355
 
321
356
def _win32_fixdrive(path):
322
357
    """Force drive letters to be consistent.
323
358
 
412
447
realpath = _posix_realpath
413
448
pathjoin = os.path.join
414
449
normpath = _posix_normpath
 
450
path_from_environ = _posix_path_from_environ
 
451
getuser_unicode = _posix_getuser_unicode
415
452
getcwd = os.getcwdu
416
453
rename = os.rename
417
454
dirname = os.path.dirname
473
510
    f = win32utils.get_unicode_argv     # special function or None
474
511
    if f is not None:
475
512
        get_unicode_argv = f
 
513
    path_from_environ = win32utils.get_environ_unicode
 
514
    getuser_unicode = win32utils.get_user_name
476
515
 
477
516
elif sys.platform == 'darwin':
478
517
    getcwd = _mac_getcwd
910
949
    return os.fstat(f.fileno())[stat.ST_SIZE]
911
950
 
912
951
 
913
 
# Define rand_bytes based on platform.
914
 
try:
915
 
    # Python 2.4 and later have os.urandom,
916
 
    # but it doesn't work on some arches
917
 
    os.urandom(1)
918
 
    rand_bytes = os.urandom
919
 
except (NotImplementedError, AttributeError):
920
 
    # If python doesn't have os.urandom, or it doesn't work,
921
 
    # then try to first pull random data from /dev/urandom
 
952
# Alias os.urandom to support platforms (which?) without /dev/urandom and 
 
953
# override if it doesn't work. Avoid checking on windows where there is
 
954
# significant initialisation cost that can be avoided for some bzr calls.
 
955
 
 
956
rand_bytes = os.urandom
 
957
 
 
958
if rand_bytes.__module__ != "nt":
922
959
    try:
923
 
        rand_bytes = file('/dev/urandom', 'rb').read
924
 
    # Otherwise, use this hack as a last resort
925
 
    except (IOError, OSError):
 
960
        rand_bytes(1)
 
961
    except NotImplementedError:
926
962
        # not well seeded, but better than nothing
927
963
        def rand_bytes(n):
928
964
            import random
958
994
    rps = []
959
995
    for f in ps:
960
996
        if f == '..':
961
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
997
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
962
998
        elif (f == '.') or (f == ''):
963
999
            pass
964
1000
        else:
969
1005
def joinpath(p):
970
1006
    for f in p:
971
1007
        if (f == '..') or (f is None) or (f == ''):
972
 
            raise errors.BzrError("sorry, %r not allowed in path" % f)
 
1008
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
973
1009
    return pathjoin(*p)
974
1010
 
975
1011
 
1019
1055
def report_extension_load_failures():
1020
1056
    if not _extension_load_failures:
1021
1057
        return
1022
 
    from bzrlib.config import GlobalConfig
1023
 
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
1058
    if config.GlobalStack().get('ignore_missing_extensions'):
1024
1059
        return
1025
1060
    # the warnings framework should by default show this only once
1026
1061
    from bzrlib.trace import warning
1188
1223
 
1189
1224
    if len(base) < MIN_ABS_PATHLENGTH:
1190
1225
        # must have space for e.g. a drive letter
1191
 
        raise ValueError('%r is too short to calculate a relative path'
 
1226
        raise ValueError(gettext('%r is too short to calculate a relative path')
1192
1227
            % (base,))
1193
1228
 
1194
1229
    rp = abspath(path)
1769
1804
    """
1770
1805
    global _selected_dir_reader
1771
1806
    if _selected_dir_reader is None:
1772
 
        fs_encoding = _fs_enc.upper()
1773
1807
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
1774
1808
            # Win98 doesn't have unicode apis like FindFirstFileW
1775
1809
            # TODO: We possibly could support Win98 by falling back to the
1781
1815
                _selected_dir_reader = Win32ReadDir()
1782
1816
            except ImportError:
1783
1817
                pass
1784
 
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1785
 
            # ANSI_X3.4-1968 is a form of ASCII
 
1818
        elif _fs_enc in ('utf-8', 'ascii'):
1786
1819
            try:
1787
1820
                from bzrlib._readdir_pyx import UTF8DirReader
1788
1821
                _selected_dir_reader = UTF8DirReader()
1947
1980
_cached_user_encoding = None
1948
1981
 
1949
1982
 
1950
 
def get_user_encoding(use_cache=True):
 
1983
def get_user_encoding(use_cache=DEPRECATED_PARAMETER):
1951
1984
    """Find out what the preferred user encoding is.
1952
1985
 
1953
1986
    This is generally the encoding that is used for command line parameters
1954
1987
    and file contents. This may be different from the terminal encoding
1955
1988
    or the filesystem encoding.
1956
1989
 
1957
 
    :param  use_cache:  Enable cache for detected encoding.
1958
 
                        (This parameter is turned on by default,
1959
 
                        and required only for selftesting)
1960
 
 
1961
1990
    :return: A string defining the preferred user encoding
1962
1991
    """
1963
1992
    global _cached_user_encoding
1964
 
    if _cached_user_encoding is not None and use_cache:
 
1993
    if deprecated_passed(use_cache):
 
1994
        warn_deprecated("use_cache should only have been used for tests",
 
1995
            DeprecationWarning, stacklevel=2) 
 
1996
    if _cached_user_encoding is not None:
1965
1997
        return _cached_user_encoding
1966
1998
 
1967
 
    if sys.platform == 'darwin':
1968
 
        # python locale.getpreferredencoding() always return
1969
 
        # 'mac-roman' on darwin. That's a lie.
1970
 
        sys.platform = 'posix'
1971
 
        try:
1972
 
            if os.environ.get('LANG', None) is None:
1973
 
                # If LANG is not set, we end up with 'ascii', which is bad
1974
 
                # ('mac-roman' is more than ascii), so we set a default which
1975
 
                # will give us UTF-8 (which appears to work in all cases on
1976
 
                # OSX). Users are still free to override LANG of course, as
1977
 
                # long as it give us something meaningful. This work-around
1978
 
                # *may* not be needed with python 3k and/or OSX 10.5, but will
1979
 
                # work with them too -- vila 20080908
1980
 
                os.environ['LANG'] = 'en_US.UTF-8'
1981
 
            import locale
1982
 
        finally:
1983
 
            sys.platform = 'darwin'
 
1999
    if os.name == 'posix' and getattr(locale, 'CODESET', None) is not None:
 
2000
        # Use the existing locale settings and call nl_langinfo directly
 
2001
        # rather than going through getpreferredencoding. This avoids
 
2002
        # <http://bugs.python.org/issue6202> on OSX Python 2.6 and the
 
2003
        # possibility of the setlocale call throwing an error.
 
2004
        user_encoding = locale.nl_langinfo(locale.CODESET)
1984
2005
    else:
1985
 
        import locale
 
2006
        # GZ 2011-12-19: On windows could call GetACP directly instead.
 
2007
        user_encoding = locale.getpreferredencoding(False)
1986
2008
 
1987
2009
    try:
1988
 
        user_encoding = locale.getpreferredencoding()
1989
 
    except locale.Error, e:
1990
 
        sys.stderr.write('bzr: warning: %s\n'
1991
 
                         '  Could not determine what text encoding to use.\n'
1992
 
                         '  This error usually means your Python interpreter\n'
1993
 
                         '  doesn\'t support the locale set by $LANG (%s)\n'
1994
 
                         "  Continuing with ascii encoding.\n"
1995
 
                         % (e, os.environ.get('LANG')))
1996
 
        user_encoding = 'ascii'
1997
 
 
1998
 
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
1999
 
    # treat that as ASCII, and not support printing unicode characters to the
2000
 
    # console.
2001
 
    #
2002
 
    # For python scripts run under vim, we get '', so also treat that as ASCII
2003
 
    if user_encoding in (None, 'cp0', ''):
2004
 
        user_encoding = 'ascii'
2005
 
    else:
2006
 
        # check encoding
2007
 
        try:
2008
 
            codecs.lookup(user_encoding)
2009
 
        except LookupError:
 
2010
        user_encoding = codecs.lookup(user_encoding).name
 
2011
    except LookupError:
 
2012
        if user_encoding not in ("", "cp0"):
2010
2013
            sys.stderr.write('bzr: warning:'
2011
2014
                             ' unknown encoding %s.'
2012
2015
                             ' Continuing with ascii encoding.\n'
2013
2016
                             % user_encoding
2014
2017
                            )
2015
 
            user_encoding = 'ascii'
2016
 
 
2017
 
    if use_cache:
2018
 
        _cached_user_encoding = user_encoding
2019
 
 
 
2018
        user_encoding = 'ascii'
 
2019
    else:
 
2020
        # Get 'ascii' when setlocale has not been called or LANG=C or unset.
 
2021
        if user_encoding == 'ascii':
 
2022
            if sys.platform == 'darwin':
 
2023
                # OSX is special-cased in Python to have a UTF-8 filesystem
 
2024
                # encoding and previously had LANG set here if not present.
 
2025
                user_encoding = 'utf-8'
 
2026
            # GZ 2011-12-19: Maybe UTF-8 should be the default in this case
 
2027
            #                for some other posix platforms as well.
 
2028
 
 
2029
    _cached_user_encoding = user_encoding
2020
2030
    return user_encoding
2021
2031
 
2022
2032
 
2031
2041
    behaves inconsistently on different platforms.
2032
2042
    """
2033
2043
    if sys.platform == "win32":
2034
 
        import win32utils
2035
2044
        return win32utils.get_host_name()
2036
2045
    else:
2037
2046
        import socket
2212
2221
    return file_kind_from_stat_mode(mode)
2213
2222
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2214
2223
 
2215
 
 
2216
 
def file_kind(f, _lstat=os.lstat):
 
2224
def file_stat(f, _lstat=os.lstat):
2217
2225
    try:
2218
 
        return file_kind_from_stat_mode(_lstat(f).st_mode)
 
2226
        # XXX cache?
 
2227
        return _lstat(f)
2219
2228
    except OSError, e:
2220
2229
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2221
2230
            raise errors.NoSuchFile(f)
2222
2231
        raise
2223
2232
 
 
2233
def file_kind(f, _lstat=os.lstat):
 
2234
    stat_value = file_stat(f, _lstat)
 
2235
    return file_kind_from_stat_mode(stat_value.st_mode)
2224
2236
 
2225
2237
def until_no_eintr(f, *a, **kw):
2226
2238
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2270
2282
 
2271
2283
 
2272
2284
if sys.platform == "win32":
2273
 
    import msvcrt
2274
2285
    def getchar():
 
2286
        import msvcrt
2275
2287
        return msvcrt.getch()
2276
2288
else:
2277
 
    import tty
2278
 
    import termios
2279
2289
    def getchar():
 
2290
        import tty
 
2291
        import termios
2280
2292
        fd = sys.stdin.fileno()
2281
2293
        settings = termios.tcgetattr(fd)
2282
2294
        try:
2286
2298
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2287
2299
        return ch
2288
2300
 
2289
 
if sys.platform == 'linux2':
 
2301
if sys.platform.startswith('linux'):
2290
2302
    def _local_concurrency():
2291
2303
        try:
2292
2304
            return os.sysconf('SC_NPROCESSORS_ONLN')
2331
2343
    if concurrency is None:
2332
2344
        try:
2333
2345
            import multiprocessing
2334
 
        except ImportError:
 
2346
            concurrency = multiprocessing.cpu_count()
 
2347
        except (ImportError, NotImplementedError):
2335
2348
            # multiprocessing is only available on Python >= 2.6
 
2349
            # and multiprocessing.cpu_count() isn't implemented on all
 
2350
            # platforms
2336
2351
            try:
2337
2352
                concurrency = _local_concurrency()
2338
2353
            except (OSError, IOError):
2339
2354
                pass
2340
 
        else:
2341
 
            concurrency = multiprocessing.cpu_count()
2342
2355
    try:
2343
2356
        concurrency = int(concurrency)
2344
2357
    except (TypeError, ValueError):
2406
2419
    open_file = open
2407
2420
 
2408
2421
 
2409
 
def getuser_unicode():
2410
 
    """Return the username as unicode.
2411
 
    """
2412
 
    try:
2413
 
        user_encoding = get_user_encoding()
2414
 
        username = getpass.getuser().decode(user_encoding)
2415
 
    except UnicodeDecodeError:
2416
 
        raise errors.BzrError("Can't decode username as %s." % \
2417
 
                user_encoding)
2418
 
    except ImportError, e:
2419
 
        if sys.platform != 'win32':
2420
 
            raise
2421
 
        if str(e) != 'No module named pwd':
2422
 
            raise
2423
 
        # https://bugs.launchpad.net/bzr/+bug/660174
2424
 
        # getpass.getuser() is unable to return username on Windows
2425
 
        # if there is no USERNAME environment variable set.
2426
 
        # That could be true if bzr is running as a service,
2427
 
        # e.g. running `bzr serve` as a service on Windows.
2428
 
        # We should not fail with traceback in this case.
2429
 
        username = u'UNKNOWN'
2430
 
    return username
2431
 
 
2432
 
 
2433
2422
def available_backup_name(base, exists):
2434
2423
    """Find a non-existing backup file name.
2435
2424
 
2547
2536
            raise
2548
2537
        if os.listdir(path) != []:
2549
2538
            raise exception_class(path)
 
2539
 
 
2540
 
 
2541
def is_environment_error(evalue):
 
2542
    """True if exception instance is due to a process environment issue
 
2543
 
 
2544
    This includes OSError and IOError, but also other errors that come from
 
2545
    the operating system or core libraries but are not subclasses of those.
 
2546
    """
 
2547
    if isinstance(evalue, (EnvironmentError, select.error)):
 
2548
        return True
 
2549
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
 
2550
        return True
 
2551
    return False