/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Vincent Ladeuil
  • Date: 2010-06-17 09:23:19 UTC
  • mfrom: (5301 +trunk)
  • mto: (5247.1.8 first-try)
  • mto: This revision was merged to the branch mainline in revision 5326.
  • Revision ID: v.ladeuil+lp@free.fr-20100617092319-da2bzdtf3j0voynf
Merge bzr.dev into cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
import errno
17
18
import os
18
19
import re
19
20
import stat
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
21
import sys
22
22
import time
23
23
import codecs
25
25
from bzrlib.lazy_import import lazy_import
26
26
lazy_import(globals(), """
27
27
from datetime import datetime
28
 
import errno
29
 
from ntpath import (abspath as _nt_abspath,
30
 
                    join as _nt_join,
31
 
                    normpath as _nt_normpath,
32
 
                    realpath as _nt_realpath,
33
 
                    splitdrive as _nt_splitdrive,
34
 
                    )
 
28
import getpass
 
29
import ntpath
35
30
import posixpath
36
31
import shutil
37
 
from shutil import (
38
 
    rmtree,
39
 
    )
40
32
import socket
41
33
import subprocess
42
34
import tempfile
43
 
from tempfile import (
44
 
    mkdtemp,
45
 
    )
46
35
import unicodedata
47
36
 
48
37
from bzrlib import (
303
292
    running python.exe under cmd.exe return capital C:\\
304
293
    running win32 python inside a cygwin shell returns lowercase c:\\
305
294
    """
306
 
    drive, path = _nt_splitdrive(path)
 
295
    drive, path = ntpath.splitdrive(path)
307
296
    return drive.upper() + path
308
297
 
309
298
 
310
299
def _win32_abspath(path):
311
 
    # Real _nt_abspath doesn't have a problem with a unicode cwd
312
 
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
 
300
    # Real ntpath.abspath doesn't have a problem with a unicode cwd
 
301
    return _win32_fixdrive(ntpath.abspath(unicode(path)).replace('\\', '/'))
313
302
 
314
303
 
315
304
def _win98_abspath(path):
326
315
    #   /path       => C:/path
327
316
    path = unicode(path)
328
317
    # check for absolute path
329
 
    drive = _nt_splitdrive(path)[0]
 
318
    drive = ntpath.splitdrive(path)[0]
330
319
    if drive == '' and path[:2] not in('//','\\\\'):
331
320
        cwd = os.getcwdu()
332
321
        # we cannot simply os.path.join cwd and path
333
322
        # because os.path.join('C:','/path') produce '/path'
334
323
        # and this is incorrect
335
324
        if path[:1] in ('/','\\'):
336
 
            cwd = _nt_splitdrive(cwd)[0]
 
325
            cwd = ntpath.splitdrive(cwd)[0]
337
326
            path = path[1:]
338
327
        path = cwd + '\\' + path
339
 
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
 
328
    return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
340
329
 
341
330
 
342
331
def _win32_realpath(path):
343
 
    # Real _nt_realpath doesn't have a problem with a unicode cwd
344
 
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
 
332
    # Real ntpath.realpath doesn't have a problem with a unicode cwd
 
333
    return _win32_fixdrive(ntpath.realpath(unicode(path)).replace('\\', '/'))
345
334
 
346
335
 
347
336
def _win32_pathjoin(*args):
348
 
    return _nt_join(*args).replace('\\', '/')
 
337
    return ntpath.join(*args).replace('\\', '/')
349
338
 
350
339
 
351
340
def _win32_normpath(path):
352
 
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
 
341
    return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
353
342
 
354
343
 
355
344
def _win32_getcwd():
360
349
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
361
350
 
362
351
 
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
 
 
371
352
def _win32_rename(old, new):
372
353
    """We expect to be able to atomically replace 'new' with old.
373
354
 
375
356
    and then deleted.
376
357
    """
377
358
    try:
378
 
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
 
359
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
379
360
    except OSError, e:
380
361
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
381
362
            # If we try to rename a non-existant file onto cwd, we get
386
367
        raise
387
368
 
388
369
 
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
 
 
399
370
def _mac_getcwd():
400
371
    return unicodedata.normalize('NFC', os.getcwdu())
401
372
 
406
377
realpath = _posix_realpath
407
378
pathjoin = os.path.join
408
379
normpath = os.path.normpath
409
 
rename = _wrapped_rename # overridden below on win32
410
380
getcwd = os.getcwdu
 
381
rename = os.rename
411
382
dirname = os.path.dirname
412
383
basename = os.path.basename
413
384
split = os.path.split
414
385
splitext = os.path.splitext
415
 
# These were already imported into local scope
416
 
# mkdtemp = tempfile.mkdtemp
417
 
# rmtree = shutil.rmtree
 
386
mkdtemp = tempfile.mkdtemp
 
387
rmtree = shutil.rmtree
418
388
 
419
389
MIN_ABS_PATHLENGTH = 1
420
390
 
519
489
def isdir(f):
520
490
    """True if f is an accessible directory."""
521
491
    try:
522
 
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
492
        return stat.S_ISDIR(os.lstat(f)[stat.ST_MODE])
523
493
    except OSError:
524
494
        return False
525
495
 
527
497
def isfile(f):
528
498
    """True if f is a regular file."""
529
499
    try:
530
 
        return S_ISREG(os.lstat(f)[ST_MODE])
 
500
        return stat.S_ISREG(os.lstat(f)[stat.ST_MODE])
531
501
    except OSError:
532
502
        return False
533
503
 
534
504
def islink(f):
535
505
    """True if f is a symlink."""
536
506
    try:
537
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
507
        return stat.S_ISLNK(os.lstat(f)[stat.ST_MODE])
538
508
    except OSError:
539
509
        return False
540
510
 
880
850
 
881
851
def filesize(f):
882
852
    """Return size of given open file."""
883
 
    return os.fstat(f.fileno())[ST_SIZE]
 
853
    return os.fstat(f.fileno())[stat.ST_SIZE]
884
854
 
885
855
 
886
856
# Define rand_bytes based on platform.
1338
1308
def normalizes_filenames():
1339
1309
    """Return True if this platform normalizes unicode filenames.
1340
1310
 
1341
 
    Mac OSX does, Windows/Linux do not.
 
1311
    Only Mac OSX.
1342
1312
    """
1343
1313
    return _platform_normalizes_filenames
1344
1314
 
1349
1319
    On platforms where the system normalizes filenames (Mac OSX),
1350
1320
    you can access a file by any path which will normalize correctly.
1351
1321
    On platforms where the system does not normalize filenames
1352
 
    (Windows, Linux), you have to access a file by its exact path.
 
1322
    (everything else), you have to access a file by its exact path.
1353
1323
 
1354
1324
    Internally, bzr only supports NFC normalization, since that is
1355
1325
    the standard for XML documents.
1417
1387
terminal_width() returns None.
1418
1388
"""
1419
1389
 
 
1390
# Keep some state so that terminal_width can detect if _terminal_size has
 
1391
# returned a different size since the process started.  See docstring and
 
1392
# comments of terminal_width for details.
 
1393
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
 
1394
_terminal_size_state = 'no_data'
 
1395
_first_terminal_size = None
1420
1396
 
1421
1397
def terminal_width():
1422
1398
    """Return terminal width.
1426
1402
    The rules are:
1427
1403
    - if BZR_COLUMNS is set, returns its value
1428
1404
    - if there is no controlling terminal, returns None
 
1405
    - query the OS, if the queried size has changed since the last query,
 
1406
      return its value,
1429
1407
    - if COLUMNS is set, returns its value,
 
1408
    - if the OS has a value (even though it's never changed), return its value.
1430
1409
 
1431
1410
    From there, we need to query the OS to get the size of the controlling
1432
1411
    terminal.
1433
1412
 
1434
 
    Unices:
 
1413
    On Unices we query the OS by:
1435
1414
    - get termios.TIOCGWINSZ
1436
1415
    - if an error occurs or a negative value is obtained, returns None
1437
1416
 
1438
 
    Windows:
1439
 
    
 
1417
    On Windows we query the OS by:
1440
1418
    - win32utils.get_console_size() decides,
1441
1419
    - returns None on error (provided default value)
1442
1420
    """
 
1421
    # Note to implementors: if changing the rules for determining the width,
 
1422
    # make sure you've considered the behaviour in these cases:
 
1423
    #  - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
 
1424
    #  - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
 
1425
    #    0,0.
 
1426
    #  - (add more interesting cases here, if you find any)
 
1427
    # Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
 
1428
    # but we don't want to register a signal handler because it is impossible
 
1429
    # to do so without risking EINTR errors in Python <= 2.6.5 (see
 
1430
    # <http://bugs.python.org/issue8354>).  Instead we check TIOCGWINSZ every
 
1431
    # time so we can notice if the reported size has changed, which should have
 
1432
    # a similar effect.
1443
1433
 
1444
1434
    # If BZR_COLUMNS is set, take it, user is always right
1445
1435
    try:
1448
1438
        pass
1449
1439
 
1450
1440
    isatty = getattr(sys.stdout, 'isatty', None)
1451
 
    if  isatty is None or not isatty():
 
1441
    if isatty is None or not isatty():
1452
1442
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
1453
1443
        return None
1454
1444
 
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))
 
1445
    # Query the OS
 
1446
    width, height = os_size = _terminal_size(None, None)
 
1447
    global _first_terminal_size, _terminal_size_state
 
1448
    if _terminal_size_state == 'no_data':
 
1449
        _first_terminal_size = os_size
 
1450
        _terminal_size_state = 'unchanged'
 
1451
    elif (_terminal_size_state == 'unchanged' and
 
1452
          _first_terminal_size != os_size):
 
1453
        _terminal_size_state = 'changed'
 
1454
 
 
1455
    # If the OS claims to know how wide the terminal is, and this value has
 
1456
    # ever changed, use that.
 
1457
    if _terminal_size_state == 'changed':
 
1458
        if width is not None and width > 0:
 
1459
            return width
 
1460
 
 
1461
    # If COLUMNS is set, use it.
1458
1462
    try:
1459
1463
        return int(os.environ['COLUMNS'])
1460
1464
    except (KeyError, ValueError):
1461
1465
        pass
1462
1466
 
1463
 
    width, height = _terminal_size(None, None)
1464
 
    if width <= 0:
1465
 
        # Consider invalid values as meaning no width
1466
 
        return None
 
1467
    # Finally, use an unchanged size from the OS, if we have one.
 
1468
    if _terminal_size_state == 'unchanged':
 
1469
        if width is not None and width > 0:
 
1470
            return width
1467
1471
 
1468
 
    return width
 
1472
    # The width could not be determined.
 
1473
    return None
1469
1474
 
1470
1475
 
1471
1476
def _win32_terminal_size(width, height):
1498
1503
    _terminal_size = _ioctl_terminal_size
1499
1504
 
1500
1505
 
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:
1516
 
        try:
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
1522
 
            pass
1523
 
        _registered_sigwinch = True
1524
 
 
1525
 
 
1526
1506
def supports_executable():
1527
1507
    return sys.platform != "win32"
1528
1508
 
2095
2075
    base = dirname(bzrlib.__file__)
2096
2076
    if getattr(sys, 'frozen', None):    # bzr.exe
2097
2077
        base = abspath(pathjoin(base, '..', '..'))
2098
 
    filename = pathjoin(base, resource_relpath)
2099
 
    return open(filename, 'rU').read()
2100
 
 
 
2078
    f = file(pathjoin(base, resource_relpath), "rU")
 
2079
    try:
 
2080
        return f.read()
 
2081
    finally:
 
2082
        f.close()
2101
2083
 
2102
2084
def file_kind_from_stat_mode_thunk(mode):
2103
2085
    global file_kind_from_stat_mode
2302
2284
        return os.fdopen(os.open(filename, flags), mode, bufsize)
2303
2285
else:
2304
2286
    open_file = open
 
2287
 
 
2288
 
 
2289
def getuser_unicode():
 
2290
    """Return the username as unicode.
 
2291
    """
 
2292
    try:
 
2293
        user_encoding = get_user_encoding()
 
2294
        username = getpass.getuser().decode(user_encoding)
 
2295
    except UnicodeDecodeError:
 
2296
        raise errors.BzrError("Can't decode username as %s." % \
 
2297
                user_encoding)
 
2298
    return username