← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Samuel Bronson
  • Date: 2012-08-30 20:36:18 UTC
  • mto: (6015.57.3 2.4)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: naesten@gmail.com-20120830203618-y2dzw91nqpvpgxvx
Update INSTALL for switch to Python 2.6 and up.

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
 
 
19
17
import errno
20
18
import os
21
19
import re
28
26
lazy_import(globals(), """
29
27
from datetime import datetime
30
28
import getpass
31
 
import locale
32
29
import ntpath
33
30
import posixpath
34
 
import select
35
31
# We need to import both shutil and rmtree as we export the later on posix
36
32
# and need the former on windows
37
33
import shutil
46
42
 
47
43
from bzrlib import (
48
44
    cache_utf8,
49
 
    config,
50
45
    errors,
51
46
    trace,
52
47
    win32utils,
53
48
    )
54
 
from bzrlib.i18n import gettext
55
49
""")
56
50
 
57
51
from bzrlib.symbol_versioning import (
58
 
    DEPRECATED_PARAMETER,
59
52
    deprecated_function,
60
53
    deprecated_in,
61
 
    deprecated_passed,
62
 
    warn as warn_deprecated,
63
54
    )
64
55
 
65
56
from hashlib import (
69
60
 
70
61
 
71
62
import bzrlib
72
 
from bzrlib import symbol_versioning, _fs_enc
 
63
from bzrlib import symbol_versioning
73
64
 
74
65
 
75
66
# Cross platform wall-clock time functionality with decent resolution.
97
88
        user_encoding = get_user_encoding()
98
89
        return [a.decode(user_encoding) for a in sys.argv[1:]]
99
90
    except UnicodeDecodeError:
100
 
        raise errors.BzrError(gettext("Parameter {0!r} encoding is unsupported by {1} "
101
 
            "application locale.").format(a, user_encoding))
 
91
        raise errors.BzrError("Parameter %r encoding is unsupported by %s "
 
92
            "application locale." % (a, user_encoding))
102
93
 
103
94
 
104
95
def make_readonly(filename):
217
208
            if e.errno == errno.ENOENT:
218
209
                return False;
219
210
            else:
220
 
                raise errors.BzrError(gettext("lstat/stat of ({0!r}): {1!r}").format(f, e))
 
211
                raise errors.BzrError("lstat/stat of (%r): %r" % (f, e))
221
212
 
222
213
 
223
214
def fancy_rename(old, new, rename_func, unlink_func):
299
290
# choke on a Unicode string containing a relative path if
300
291
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
301
292
# string.
 
293
_fs_enc = sys.getfilesystemencoding() or 'utf-8'
302
294
def _posix_abspath(path):
303
295
    # jam 20060426 rather than encoding to fsencoding
304
296
    # copy posixpath.abspath, but use os.getcwdu instead
326
318
    return path
327
319
 
328
320
 
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_get_home_dir():
346
 
    """Get the home directory of the current user as a unicode path"""
347
 
    path = posixpath.expanduser("~")
348
 
    try:
349
 
        return path.decode(_fs_enc)
350
 
    except UnicodeDecodeError:
351
 
        raise errors.BadFilenameEncoding(path, _fs_enc)
352
 
 
353
 
 
354
 
def _posix_getuser_unicode():
355
 
    """Get username from environment or password database as unicode"""
356
 
    name = getpass.getuser()
357
 
    user_encoding = get_user_encoding()
358
 
    try:
359
 
        return name.decode(user_encoding)
360
 
    except UnicodeDecodeError:
361
 
        raise errors.BzrError("Encoding of username %r is unsupported by %s "
362
 
            "application locale." % (name, user_encoding))
363
 
 
364
 
 
365
321
def _win32_fixdrive(path):
366
322
    """Force drive letters to be consistent.
367
323
 
456
412
realpath = _posix_realpath
457
413
pathjoin = os.path.join
458
414
normpath = _posix_normpath
459
 
path_from_environ = _posix_path_from_environ
460
 
_get_home_dir = _posix_get_home_dir
461
 
getuser_unicode = _posix_getuser_unicode
462
415
getcwd = os.getcwdu
463
416
rename = os.rename
464
417
dirname = os.path.dirname
520
473
    f = win32utils.get_unicode_argv     # special function or None
521
474
    if f is not None:
522
475
        get_unicode_argv = f
523
 
    path_from_environ = win32utils.get_environ_unicode
524
 
    _get_home_dir = win32utils.get_home_location
525
 
    getuser_unicode = win32utils.get_user_name
526
476
 
527
477
elif sys.platform == 'darwin':
528
478
    getcwd = _mac_getcwd
960
910
    return os.fstat(f.fileno())[stat.ST_SIZE]
961
911
 
962
912
 
963
 
# Alias os.urandom to support platforms (which?) without /dev/urandom and 
964
 
# override if it doesn't work. Avoid checking on windows where there is
965
 
# significant initialisation cost that can be avoided for some bzr calls.
966
 
 
967
 
rand_bytes = os.urandom
968
 
 
969
 
if rand_bytes.__module__ != "nt":
 
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
970
922
    try:
971
 
        rand_bytes(1)
972
 
    except NotImplementedError:
 
923
        rand_bytes = file('/dev/urandom', 'rb').read
 
924
    # Otherwise, use this hack as a last resort
 
925
    except (IOError, OSError):
973
926
        # not well seeded, but better than nothing
974
927
        def rand_bytes(n):
975
928
            import random
1005
958
    rps = []
1006
959
    for f in ps:
1007
960
        if f == '..':
1008
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
961
            raise errors.BzrError("sorry, %r not allowed in path" % f)
1009
962
        elif (f == '.') or (f == ''):
1010
963
            pass
1011
964
        else:
1016
969
def joinpath(p):
1017
970
    for f in p:
1018
971
        if (f == '..') or (f is None) or (f == ''):
1019
 
            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)
 
972
            raise errors.BzrError("sorry, %r not allowed in path" % f)
1020
973
    return pathjoin(*p)
1021
974
 
1022
975
 
1066
1019
def report_extension_load_failures():
1067
1020
    if not _extension_load_failures:
1068
1021
        return
1069
 
    if config.GlobalStack().get('ignore_missing_extensions'):
 
1022
    from bzrlib.config import GlobalConfig
 
1023
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
1070
1024
        return
1071
1025
    # the warnings framework should by default show this only once
1072
1026
    from bzrlib.trace import warning
1234
1188
 
1235
1189
    if len(base) < MIN_ABS_PATHLENGTH:
1236
1190
        # must have space for e.g. a drive letter
1237
 
        raise ValueError(gettext('%r is too short to calculate a relative path')
 
1191
        raise ValueError('%r is too short to calculate a relative path'
1238
1192
            % (base,))
1239
1193
 
1240
1194
    rp = abspath(path)
1815
1769
    """
1816
1770
    global _selected_dir_reader
1817
1771
    if _selected_dir_reader is None:
 
1772
        fs_encoding = _fs_enc.upper()
1818
1773
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
1819
1774
            # Win98 doesn't have unicode apis like FindFirstFileW
1820
1775
            # TODO: We possibly could support Win98 by falling back to the
1826
1781
                _selected_dir_reader = Win32ReadDir()
1827
1782
            except ImportError:
1828
1783
                pass
1829
 
        elif _fs_enc in ('utf-8', 'ascii'):
 
1784
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1785
            # ANSI_X3.4-1968 is a form of ASCII
1830
1786
            try:
1831
1787
                from bzrlib._readdir_pyx import UTF8DirReader
1832
1788
                _selected_dir_reader = UTF8DirReader()
1991
1947
_cached_user_encoding = None
1992
1948
 
1993
1949
 
1994
 
def get_user_encoding(use_cache=DEPRECATED_PARAMETER):
 
1950
def get_user_encoding(use_cache=True):
1995
1951
    """Find out what the preferred user encoding is.
1996
1952
 
1997
1953
    This is generally the encoding that is used for command line parameters
1998
1954
    and file contents. This may be different from the terminal encoding
1999
1955
    or the filesystem encoding.
2000
1956
 
 
1957
    :param  use_cache:  Enable cache for detected encoding.
 
1958
                        (This parameter is turned on by default,
 
1959
                        and required only for selftesting)
 
1960
 
2001
1961
    :return: A string defining the preferred user encoding
2002
1962
    """
2003
1963
    global _cached_user_encoding
2004
 
    if deprecated_passed(use_cache):
2005
 
        warn_deprecated("use_cache should only have been used for tests",
2006
 
            DeprecationWarning, stacklevel=2) 
2007
 
    if _cached_user_encoding is not None:
 
1964
    if _cached_user_encoding is not None and use_cache:
2008
1965
        return _cached_user_encoding
2009
1966
 
2010
 
    if os.name == 'posix' and getattr(locale, 'CODESET', None) is not None:
2011
 
        # Use the existing locale settings and call nl_langinfo directly
2012
 
        # rather than going through getpreferredencoding. This avoids
2013
 
        # <http://bugs.python.org/issue6202> on OSX Python 2.6 and the
2014
 
        # possibility of the setlocale call throwing an error.
2015
 
        user_encoding = locale.nl_langinfo(locale.CODESET)
 
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'
2016
1984
    else:
2017
 
        # GZ 2011-12-19: On windows could call GetACP directly instead.
2018
 
        user_encoding = locale.getpreferredencoding(False)
 
1985
        import locale
2019
1986
 
2020
1987
    try:
2021
 
        user_encoding = codecs.lookup(user_encoding).name
2022
 
    except LookupError:
2023
 
        if user_encoding not in ("", "cp0"):
 
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:
2024
2010
            sys.stderr.write('bzr: warning:'
2025
2011
                             ' unknown encoding %s.'
2026
2012
                             ' Continuing with ascii encoding.\n'
2027
2013
                             % user_encoding
2028
2014
                            )
2029
 
        user_encoding = 'ascii'
2030
 
    else:
2031
 
        # Get 'ascii' when setlocale has not been called or LANG=C or unset.
2032
 
        if user_encoding == 'ascii':
2033
 
            if sys.platform == 'darwin':
2034
 
                # OSX is special-cased in Python to have a UTF-8 filesystem
2035
 
                # encoding and previously had LANG set here if not present.
2036
 
                user_encoding = 'utf-8'
2037
 
            # GZ 2011-12-19: Maybe UTF-8 should be the default in this case
2038
 
            #                for some other posix platforms as well.
2039
 
 
2040
 
    _cached_user_encoding = user_encoding
 
2015
            user_encoding = 'ascii'
 
2016
 
 
2017
    if use_cache:
 
2018
        _cached_user_encoding = user_encoding
 
2019
 
2041
2020
    return user_encoding
2042
2021
 
2043
2022
 
2052
2031
    behaves inconsistently on different platforms.
2053
2032
    """
2054
2033
    if sys.platform == "win32":
 
2034
        import win32utils
2055
2035
        return win32utils.get_host_name()
2056
2036
    else:
2057
2037
        import socket
2232
2212
    return file_kind_from_stat_mode(mode)
2233
2213
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
2234
2214
 
2235
 
def file_stat(f, _lstat=os.lstat):
 
2215
 
 
2216
def file_kind(f, _lstat=os.lstat):
2236
2217
    try:
2237
 
        # XXX cache?
2238
 
        return _lstat(f)
 
2218
        return file_kind_from_stat_mode(_lstat(f).st_mode)
2239
2219
    except OSError, e:
2240
2220
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
2241
2221
            raise errors.NoSuchFile(f)
2242
2222
        raise
2243
2223
 
2244
 
def file_kind(f, _lstat=os.lstat):
2245
 
    stat_value = file_stat(f, _lstat)
2246
 
    return file_kind_from_stat_mode(stat_value.st_mode)
2247
2224
 
2248
2225
def until_no_eintr(f, *a, **kw):
2249
2226
    """Run f(*a, **kw), retrying if an EINTR error occurs.
2293
2270
 
2294
2271
 
2295
2272
if sys.platform == "win32":
 
2273
    import msvcrt
2296
2274
    def getchar():
2297
 
        import msvcrt
2298
2275
        return msvcrt.getch()
2299
2276
else:
 
2277
    import tty
 
2278
    import termios
2300
2279
    def getchar():
2301
 
        import tty
2302
 
        import termios
2303
2280
        fd = sys.stdin.fileno()
2304
2281
        settings = termios.tcgetattr(fd)
2305
2282
        try:
2309
2286
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2310
2287
        return ch
2311
2288
 
2312
 
if sys.platform.startswith('linux'):
 
2289
if sys.platform == 'linux2':
2313
2290
    def _local_concurrency():
2314
2291
        try:
2315
2292
            return os.sysconf('SC_NPROCESSORS_ONLN')
2354
2331
    if concurrency is None:
2355
2332
        try:
2356
2333
            import multiprocessing
2357
 
            concurrency = multiprocessing.cpu_count()
2358
 
        except (ImportError, NotImplementedError):
 
2334
        except ImportError:
2359
2335
            # multiprocessing is only available on Python >= 2.6
2360
 
            # and multiprocessing.cpu_count() isn't implemented on all
2361
 
            # platforms
2362
2336
            try:
2363
2337
                concurrency = _local_concurrency()
2364
2338
            except (OSError, IOError):
2365
2339
                pass
 
2340
        else:
 
2341
            concurrency = multiprocessing.cpu_count()
2366
2342
    try:
2367
2343
        concurrency = int(concurrency)
2368
2344
    except (TypeError, ValueError):
2430
2406
    open_file = open
2431
2407
 
2432
2408
 
 
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
2433
def available_backup_name(base, exists):
2434
2434
    """Find a non-existing backup file name.
2435
2435
 
2547
2547
            raise
2548
2548
        if os.listdir(path) != []:
2549
2549
            raise exception_class(path)
2550
 
 
2551
 
 
2552
 
def is_environment_error(evalue):
2553
 
    """True if exception instance is due to a process environment issue
2554
 
 
2555
 
    This includes OSError and IOError, but also other errors that come from
2556
 
    the operating system or core libraries but are not subclasses of those.
2557
 
    """
2558
 
    if isinstance(evalue, (EnvironmentError, select.error)):
2559
 
        return True
2560
 
    if sys.platform == "win32" and win32utils._is_pywintypes_error(evalue):
2561
 
        return True
2562
 
    return False