~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

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

• reverse the comparison (6305.3.4 to 6476)
• stop comparing with revision 6476

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

 

 

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

55

51

""")

56

52

 

57

53

from bzrlib.symbol_versioning import (

58

 

    DEPRECATED_PARAMETER,

59

54

    deprecated_function,

60

55

    deprecated_in,

61

 

    deprecated_passed,

62

 

    warn as warn_deprecated,

63

56

    )

64

57

 

65

58

from hashlib import (

69

62

 

70

63

 

71

64

import bzrlib

72

 

from bzrlib import symbol_versioning, _fs_enc

 

65

from bzrlib import symbol_versioning

73

66

 

74

67

 

75

68

# Cross platform wall-clock time functionality with decent resolution.

106

99

    mod = os.lstat(filename).st_mode

107

100

    if not stat.S_ISLNK(mod):

108

101

        mod = mod & 0777555

109

 

        chmod_if_possible(filename, mod)

 

102

        os.chmod(filename, mod)

110

103

 

111

104

 

112

105

def make_writable(filename):

113

106

    mod = os.lstat(filename).st_mode

114

107

    if not stat.S_ISLNK(mod):

115

108

        mod = mod | 0200

116

 

        chmod_if_possible(filename, mod)

117

 

 

118

 

 

119

 

def chmod_if_possible(filename, mode):

120

 

    # Set file mode if that can be safely done.

121

 

    # Sometimes even on unix the filesystem won't allow it - see

122

 

    # https://bugs.launchpad.net/bzr/+bug/606537

123

 

    try:

124

 

        # It is probably faster to just do the chmod, rather than

125

 

        # doing a stat, and then trying to compare

126

 

        os.chmod(filename, mode)

127

 

    except (IOError, OSError),e:

128

 

        # Permission/access denied seems to commonly happen on smbfs; there's

129

 

        # probably no point warning about it.

130

 

        # <https://bugs.launchpad.net/bzr/+bug/606537>

131

 

        if getattr(e, 'errno') in (errno.EPERM, errno.EACCES):

132

 

            trace.mutter("ignore error on chmod of %r: %r" % (

133

 

                filename, e))

134

 

            return

135

 

        raise

 

109

        os.chmod(filename, mod)

136

110

 

137

111

 

138

112

def minimum_path_selection(paths):

299

273

# choke on a Unicode string containing a relative path if

300

274

# os.getcwd() returns a non-sys.getdefaultencoding()-encoded

301

275

# string.

 

276

_fs_enc = sys.getfilesystemencoding() or 'utf-8'

302

277

def _posix_abspath(path):

303

278

    # jam 20060426 rather than encoding to fsencoding

304

279

    # copy posixpath.abspath, but use os.getcwdu instead

326

301

    return path

327

302

 

328

303

 

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

304

def _win32_fixdrive(path):

366

305

    """Force drive letters to be consistent.

367

306

 

456

395

realpath = _posix_realpath

457

396

pathjoin = os.path.join

458

397

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

398

getcwd = os.getcwdu

463

399

rename = os.rename

464

400

dirname = os.path.dirname

520

456

    f = win32utils.get_unicode_argv     # special function or None

521

457

    if f is not None:

522

458

        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

459

 

527

460

elif sys.platform == 'darwin':

528

461

    getcwd = _mac_getcwd

960

893

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

961

894

 

962

895

 

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

 

896

# Define rand_bytes based on platform.

 

897

try:

 

898

    # Python 2.4 and later have os.urandom,

 

899

    # but it doesn't work on some arches

 

900

    os.urandom(1)

 

901

    rand_bytes = os.urandom

 

902

except (NotImplementedError, AttributeError):

 

903

    # If python doesn't have os.urandom, or it doesn't work,

 

904

    # then try to first pull random data from /dev/urandom

970

905

    try:

971

 

        rand_bytes(1)

972

 

    except NotImplementedError:

 

906

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

 

907

    # Otherwise, use this hack as a last resort

 

908

    except (IOError, OSError):

973

909

        # not well seeded, but better than nothing

974

910

        def rand_bytes(n):

975

911

            import random

1815

1751

    """

1816

1752

    global _selected_dir_reader

1817

1753

    if _selected_dir_reader is None:

 

1754

        fs_encoding = _fs_enc.upper()

1818

1755

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

1819

1756

            # Win98 doesn't have unicode apis like FindFirstFileW

1820

1757

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

1826

1763

                _selected_dir_reader = Win32ReadDir()

1827

1764

            except ImportError:

1828

1765

                pass

1829

 

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

 

1766

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

 

1767

            # ANSI_X3.4-1968 is a form of ASCII

1830

1768

            try:

1831

1769

                from bzrlib._readdir_pyx import UTF8DirReader

1832

1770

                _selected_dir_reader = UTF8DirReader()

1991

1929

_cached_user_encoding = None

1992

1930

 

1993

1931

 

1994

 

def get_user_encoding(use_cache=DEPRECATED_PARAMETER):

 

1932

def get_user_encoding(use_cache=True):

1995

1933

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

1996

1934

 

1997

1935

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

1998

1936

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

1999

1937

    or the filesystem encoding.

2000

1938

 

 

1939

    :param  use_cache:  Enable cache for detected encoding.

 

1940

                        (This parameter is turned on by default,

 

1941

                        and required only for selftesting)

 

1942

 

2001

1943

    :return: A string defining the preferred user encoding

2002

1944

    """

2003

1945

    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:

 

1946

    if _cached_user_encoding is not None and use_cache:

2008

1947

        return _cached_user_encoding

2009

1948

 

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)

 

1949

    if sys.platform == 'darwin':

 

1950

        # python locale.getpreferredencoding() always return

 

1951

        # 'mac-roman' on darwin. That's a lie.

 

1952

        sys.platform = 'posix'

 

1953

        try:

 

1954

            if os.environ.get('LANG', None) is None:

 

1955

                # If LANG is not set, we end up with 'ascii', which is bad

 

1956

                # ('mac-roman' is more than ascii), so we set a default which

 

1957

                # will give us UTF-8 (which appears to work in all cases on

 

1958

                # OSX). Users are still free to override LANG of course, as

 

1959

                # long as it give us something meaningful. This work-around

 

1960

                # *may* not be needed with python 3k and/or OSX 10.5, but will

 

1961

                # work with them too -- vila 20080908

 

1962

                os.environ['LANG'] = 'en_US.UTF-8'

 

1963

            import locale

 

1964

        finally:

 

1965

            sys.platform = 'darwin'

2016

1966

    else:

2017

 

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

2018

 

        user_encoding = locale.getpreferredencoding(False)

 

1967

        import locale

2019

1968

 

2020

1969

    try:

2021

 

        user_encoding = codecs.lookup(user_encoding).name

2022

 

    except LookupError:

2023

 

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

 

1970

        user_encoding = locale.getpreferredencoding()

 

1971

    except locale.Error, e:

 

1972

        sys.stderr.write('bzr: warning: %s\n'

 

1973

                         '  Could not determine what text encoding to use.\n'

 

1974

                         '  This error usually means your Python interpreter\n'

 

1975

                         '  doesn\'t support the locale set by $LANG (%s)\n'

 

1976

                         "  Continuing with ascii encoding.\n"

 

1977

                         % (e, os.environ.get('LANG')))

 

1978

        user_encoding = 'ascii'

 

1979

 

 

1980

    # Windows returns 'cp0' to indicate there is no code page. So we'll just

 

1981

    # treat that as ASCII, and not support printing unicode characters to the

 

1982

    # console.

 

1983

    #

 

1984

    # For python scripts run under vim, we get '', so also treat that as ASCII

 

1985

    if user_encoding in (None, 'cp0', ''):

 

1986

        user_encoding = 'ascii'

 

1987

    else:

 

1988

        # check encoding

 

1989

        try:

 

1990

            codecs.lookup(user_encoding)

 

1991

        except LookupError:

2024

1992

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

2025

1993

                             ' unknown encoding %s.'

2026

1994

                             ' Continuing with ascii encoding.\n'

2027

1995

                             % user_encoding

2028

1996

                            )

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

 

1997

            user_encoding = 'ascii'

 

1998

 

 

1999

    if use_cache:

 

2000

        _cached_user_encoding = user_encoding

 

2001

 

2041

2002

    return user_encoding

2042

2003

 

2043

2004

 

2052

2013

    behaves inconsistently on different platforms.

2053

2014

    """

2054

2015

    if sys.platform == "win32":

 

2016

        import win32utils

2055

2017

        return win32utils.get_host_name()

2056

2018

    else:

2057

2019

        import socket

2293

2255

 

2294

2256

 

2295

2257

if sys.platform == "win32":

 

2258

    import msvcrt

2296

2259

    def getchar():

2297

 

        import msvcrt

2298

2260

        return msvcrt.getch()

2299

2261

else:

 

2262

    import tty

 

2263

    import termios

2300

2264

    def getchar():

2301

 

        import tty

2302

 

        import termios

2303

2265

        fd = sys.stdin.fileno()

2304

2266

        settings = termios.tcgetattr(fd)

2305

2267

        try:

2430

2392

    open_file = open

2431

2393

 

2432

2394

 

 

2395

def getuser_unicode():

 

2396

    """Return the username as unicode.

 

2397

    """

 

2398

    try:

 

2399

        user_encoding = get_user_encoding()

 

2400

        username = getpass.getuser().decode(user_encoding)

 

2401

    except UnicodeDecodeError:

 

2402

        raise errors.BzrError("Can't decode username as %s." % \

 

2403

                user_encoding)

 

2404

    except ImportError, e:

 

2405

        if sys.platform != 'win32':

 

2406

            raise

 

2407

        if str(e) != 'No module named pwd':

 

2408

            raise

 

2409

        # https://bugs.launchpad.net/bzr/+bug/660174

 

2410

        # getpass.getuser() is unable to return username on Windows

 

2411

        # if there is no USERNAME environment variable set.

 

2412

        # That could be true if bzr is running as a service,

 

2413

        # e.g. running `bzr serve` as a service on Windows.

 

2414

        # We should not fail with traceback in this case.

 

2415

        username = u'UNKNOWN'

 

2416

    return username

 

2417

 

 

2418

 

2433

2419

def available_backup_name(base, exists):

2434

2420

    """Find a non-existing backup file name.

2435

2421

 

2532

2518

    fn = getattr(os, 'fdatasync', getattr(os, 'fsync', None))

2533

2519

    if fn is not None:

2534

2520

        fn(fileno)

2535

 

 

2536

 

 

2537

 

def ensure_empty_directory_exists(path, exception_class):

2538

 

    """Make sure a local directory exists and is empty.

2539

 

    

2540

 

    If it does not exist, it is created.  If it exists and is not empty, an

2541

 

    instance of exception_class is raised.

2542

 

    """

2543

 

    try:

2544

 

        os.mkdir(path)

2545

 

    except OSError, e:

2546

 

        if e.errno != errno.EEXIST:

2547

 

            raise

2548

 

        if os.listdir(path) != []:

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