~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

• browse files at revision 6449.5.3
• compare with another revision
• download diff
• download tarball
• view history from revision 6449.5.3

• reverse the comparison (6449.5.3 to 6015.59.1)
• stop comparing with revision 6015.59.1

Show diffs side-by-side

added

removed

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_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

 

321

365

def _win32_fixdrive(path):

322

366

    """Force drive letters to be consistent.

323

367

 

412

456

realpath = _posix_realpath

413

457

pathjoin = os.path.join

414

458

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

415

462

getcwd = os.getcwdu

416

463

rename = os.rename

417

464

dirname = os.path.dirname

473

520

    f = win32utils.get_unicode_argv     # special function or None

474

521

    if f is not None:

475

522

        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

476

526

 

477

527

elif sys.platform == 'darwin':

478

528

    getcwd = _mac_getcwd

910

960

    return os.fstat(f.fileno())[stat.ST_SIZE]

911

961

 

912

962

 

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

 

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":

922

970

    try:

923

 

        rand_bytes = file('/dev/urandom', 'rb').read

924

 

    # Otherwise, use this hack as a last resort

925

 

    except (IOError, OSError):

 

971

        rand_bytes(1)

 

972

    except NotImplementedError:

926

973

        # not well seeded, but better than nothing

927

974

        def rand_bytes(n):

928

975

            import random

958

1005

    rps = []

959

1006

    for f in ps:

960

1007

        if f == '..':

961

 

            raise errors.BzrError("sorry, %r not allowed in path" % f)

 

1008

            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)

962

1009

        elif (f == '.') or (f == ''):

963

1010

            pass

964

1011

        else:

969

1016

def joinpath(p):

970

1017

    for f in p:

971

1018

        if (f == '..') or (f is None) or (f == ''):

972

 

            raise errors.BzrError("sorry, %r not allowed in path" % f)

 

1019

            raise errors.BzrError(gettext("sorry, %r not allowed in path") % f)

973

1020

    return pathjoin(*p)

974

1021

 

975

1022

 

1019

1066

def report_extension_load_failures():

1020

1067

    if not _extension_load_failures:

1021

1068

        return

1022

 

    from bzrlib.config import GlobalConfig

1023

 

    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):

 

1069

    if config.GlobalStack().get('ignore_missing_extensions'):

1024

1070

        return

1025

1071

    # the warnings framework should by default show this only once

1026

1072

    from bzrlib.trace import warning

1188

1234

 

1189

1235

    if len(base) < MIN_ABS_PATHLENGTH:

1190

1236

        # must have space for e.g. a drive letter

1191

 

        raise ValueError('%r is too short to calculate a relative path'

 

1237

        raise ValueError(gettext('%r is too short to calculate a relative path')

1192

1238

            % (base,))

1193

1239

 

1194

1240

    rp = abspath(path)

1769

1815

    """

1770

1816

    global _selected_dir_reader

1771

1817

    if _selected_dir_reader is None:

1772

 

        fs_encoding = _fs_enc.upper()

1773

1818

        if sys.platform == "win32" and win32utils.winver == 'Windows NT':

1774

1819

            # Win98 doesn't have unicode apis like FindFirstFileW

1775

1820

            # TODO: We possibly could support Win98 by falling back to the

1781

1826

                _selected_dir_reader = Win32ReadDir()

1782

1827

            except ImportError:

1783

1828

                pass

1784

 

        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):

1785

 

            # ANSI_X3.4-1968 is a form of ASCII

 

1829

        elif _fs_enc in ('utf-8', 'ascii'):

1786

1830

            try:

1787

1831

                from bzrlib._readdir_pyx import UTF8DirReader

1788

1832

                _selected_dir_reader = UTF8DirReader()

1947

1991

_cached_user_encoding = None

1948

1992

 

1949

1993

 

1950

 

def get_user_encoding(use_cache=True):

 

1994

def get_user_encoding(use_cache=DEPRECATED_PARAMETER):

1951

1995

    """Find out what the preferred user encoding is.

1952

1996

 

1953

1997

    This is generally the encoding that is used for command line parameters

1954

1998

    and file contents. This may be different from the terminal encoding

1955

1999

    or the filesystem encoding.

1956

2000

 

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

2001

    :return: A string defining the preferred user encoding

1962

2002

    """

1963

2003

    global _cached_user_encoding

1964

 

    if _cached_user_encoding is not None and use_cache:

 

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:

1965

2008

        return _cached_user_encoding

1966

2009

 

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'

 

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)

1984

2016

    else:

1985

 

        import locale

 

2017

        # GZ 2011-12-19: On windows could call GetACP directly instead.

 

2018

        user_encoding = locale.getpreferredencoding(False)

1986

2019

 

1987

2020

    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:

 

2021

        user_encoding = codecs.lookup(user_encoding).name

 

2022

    except LookupError:

 

2023

        if user_encoding not in ("", "cp0"):

2010

2024

            sys.stderr.write('bzr: warning:'

2011

2025

                             ' unknown encoding %s.'

2012

2026

                             ' Continuing with ascii encoding.\n'

2013

2027

                             % user_encoding

2014

2028

                            )

2015

 

            user_encoding = 'ascii'

2016

 

 

2017

 

    if use_cache:

2018

 

        _cached_user_encoding = user_encoding

2019

 

 

 

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

2020

2041

    return user_encoding

2021

2042

 

2022

2043

 

2031

2052

    behaves inconsistently on different platforms.

2032

2053

    """

2033

2054

    if sys.platform == "win32":

2034

 

        import win32utils

2035

2055

        return win32utils.get_host_name()

2036

2056

    else:

2037

2057

        import socket

2212

2232

    return file_kind_from_stat_mode(mode)

2213

2233

file_kind_from_stat_mode = file_kind_from_stat_mode_thunk

2214

2234

 

2215

 

 

2216

 

def file_kind(f, _lstat=os.lstat):

 

2235

def file_stat(f, _lstat=os.lstat):

2217

2236

    try:

2218

 

        return file_kind_from_stat_mode(_lstat(f).st_mode)

 

2237

        # XXX cache?

 

2238

        return _lstat(f)

2219

2239

    except OSError, e:

2220

2240

        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):

2221

2241

            raise errors.NoSuchFile(f)

2222

2242

        raise

2223

2243

 

 

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)

2224

2247

 

2225

2248

def until_no_eintr(f, *a, **kw):

2226

2249

    """Run f(*a, **kw), retrying if an EINTR error occurs.

2270

2293

 

2271

2294

 

2272

2295

if sys.platform == "win32":

2273

 

    import msvcrt

2274

2296

    def getchar():

 

2297

        import msvcrt

2275

2298

        return msvcrt.getch()

2276

2299

else:

2277

 

    import tty

2278

 

    import termios

2279

2300

    def getchar():

 

2301

        import tty

 

2302

        import termios

2280

2303

        fd = sys.stdin.fileno()

2281

2304

        settings = termios.tcgetattr(fd)

2282

2305

        try:

2286

2309

            termios.tcsetattr(fd, termios.TCSADRAIN, settings)

2287

2310

        return ch

2288

2311

 

2289

 

if sys.platform == 'linux2':

 

2312

if sys.platform.startswith('linux'):

2290

2313

    def _local_concurrency():

2291

2314

        try:

2292

2315

            return os.sysconf('SC_NPROCESSORS_ONLN')

2331

2354

    if concurrency is None:

2332

2355

        try:

2333

2356

            import multiprocessing

2334

 

        except ImportError:

 

2357

            concurrency = multiprocessing.cpu_count()

 

2358

        except (ImportError, NotImplementedError):

2335

2359

            # multiprocessing is only available on Python >= 2.6

 

2360

            # and multiprocessing.cpu_count() isn't implemented on all

 

2361

            # platforms

2336

2362

            try:

2337

2363

                concurrency = _local_concurrency()

2338

2364

            except (OSError, IOError):

2339

2365

                pass

2340

 

        else:

2341

 

            concurrency = multiprocessing.cpu_count()

2342

2366

    try:

2343

2367

        concurrency = int(concurrency)

2344

2368

    except (TypeError, ValueError):

2406

2430

    open_file = open

2407

2431

 

2408

2432

 

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

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1