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
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
25
25
from bzrlib.lazy_import import lazy_import
26
26
lazy_import(globals(), """
28
27
from datetime import datetime
30
from ntpath import (abspath as _nt_abspath,
32
normpath as _nt_normpath,
33
realpath as _nt_realpath,
34
splitdrive as _nt_splitdrive,
31
# We need to import both shutil and rmtree as we export the later on posix
32
# and need the former on windows
34
from shutil import rmtree
37
# We need to import both tempfile and mkdtemp as we export the later on posix
38
# and need the former on windows
43
from tempfile import (
40
from tempfile import mkdtemp
48
43
from bzrlib import (
51
from bzrlib.symbol_versioning import (
55
56
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
57
58
if sys.version_info < (2, 5):
70
71
from bzrlib import symbol_versioning
74
# Cross platform wall-clock time functionality with decent resolution.
75
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
76
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
77
# synchronized with ``time.time()``, this is only meant to be used to find
78
# delta times by subtracting from another call to this function.
79
timer_func = time.time
80
if sys.platform == 'win32':
81
timer_func = time.clock
73
83
# On win32, O_BINARY is used to indicate the file should
74
84
# be opened in binary mode, rather than text mode.
75
85
# On other platforms, O_BINARY doesn't exist, because
76
86
# they always open in binary mode, so it is okay to
77
# OR with 0 on those platforms
87
# OR with 0 on those platforms.
88
# O_NOINHERIT and O_TEXT exists only on win32 too.
78
89
O_BINARY = getattr(os, 'O_BINARY', 0)
90
O_TEXT = getattr(os, 'O_TEXT', 0)
91
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
81
94
def get_unicode_argv():
295
321
# /path => C:/path
296
322
path = unicode(path)
297
323
# check for absolute path
298
drive = _nt_splitdrive(path)[0]
324
drive = ntpath.splitdrive(path)[0]
299
325
if drive == '' and path[:2] not in('//','\\\\'):
300
326
cwd = os.getcwdu()
301
327
# we cannot simply os.path.join cwd and path
302
328
# because os.path.join('C:','/path') produce '/path'
303
329
# and this is incorrect
304
330
if path[:1] in ('/','\\'):
305
cwd = _nt_splitdrive(cwd)[0]
331
cwd = ntpath.splitdrive(cwd)[0]
307
333
path = cwd + '\\' + path
308
return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
334
return _win32_fixdrive(ntpath.normpath(path).replace('\\', '/'))
311
337
def _win32_realpath(path):
312
# Real _nt_realpath doesn't have a problem with a unicode cwd
313
return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
338
# Real ntpath.realpath doesn't have a problem with a unicode cwd
339
return _win32_fixdrive(ntpath.realpath(unicode(path)).replace('\\', '/'))
316
342
def _win32_pathjoin(*args):
317
return _nt_join(*args).replace('\\', '/')
343
return ntpath.join(*args).replace('\\', '/')
320
346
def _win32_normpath(path):
321
return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
347
return _win32_fixdrive(ntpath.normpath(unicode(path)).replace('\\', '/'))
324
350
def _win32_getcwd():
946
_extension_load_failures = []
949
def failed_to_load_extension(exception):
950
"""Handle failing to load a binary extension.
952
This should be called from the ImportError block guarding the attempt to
953
import the native extension. If this function returns, the pure-Python
954
implementation should be loaded instead::
957
>>> import bzrlib._fictional_extension_pyx
958
>>> except ImportError, e:
959
>>> bzrlib.osutils.failed_to_load_extension(e)
960
>>> import bzrlib._fictional_extension_py
962
# NB: This docstring is just an example, not a doctest, because doctest
963
# currently can't cope with the use of lazy imports in this namespace --
966
# This currently doesn't report the failure at the time it occurs, because
967
# they tend to happen very early in startup when we can't check config
968
# files etc, and also we want to report all failures but not spam the user
970
exception_str = str(exception)
971
if exception_str not in _extension_load_failures:
972
trace.mutter("failed to load compiled extension: %s" % exception_str)
973
_extension_load_failures.append(exception_str)
976
def report_extension_load_failures():
977
if not _extension_load_failures:
979
from bzrlib.config import GlobalConfig
980
if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
982
# the warnings framework should by default show this only once
983
from bzrlib.trace import warning
985
"bzr: warning: some compiled extensions could not be loaded; "
986
"see <https://answers.launchpad.net/bzr/+faq/703>")
987
# we no longer show the specific missing extensions here, because it makes
988
# the message too long and scary - see
989
# https://bugs.launchpad.net/bzr/+bug/430529
885
993
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
994
except ImportError, e:
995
failed_to_load_extension(e)
887
996
from bzrlib._chunks_to_lines_py import chunks_to_lines
1238
1373
normalized_filename = _inaccessible_normalized_filename
1376
def set_signal_handler(signum, handler, restart_syscall=True):
1377
"""A wrapper for signal.signal that also calls siginterrupt(signum, False)
1378
on platforms that support that.
1380
:param restart_syscall: if set, allow syscalls interrupted by a signal to
1381
automatically restart (by calling `signal.siginterrupt(signum,
1382
False)`). May be ignored if the feature is not available on this
1383
platform or Python version.
1387
siginterrupt = signal.siginterrupt
1389
# This python implementation doesn't provide signal support, hence no
1392
except AttributeError:
1393
# siginterrupt doesn't exist on this platform, or for this version
1395
siginterrupt = lambda signum, flag: None
1397
def sig_handler(*args):
1398
# Python resets the siginterrupt flag when a signal is
1399
# received. <http://bugs.python.org/issue8354>
1400
# As a workaround for some cases, set it back the way we want it.
1401
siginterrupt(signum, False)
1402
# Now run the handler function passed to set_signal_handler.
1405
sig_handler = handler
1406
old_handler = signal.signal(signum, sig_handler)
1408
siginterrupt(signum, False)
1412
default_terminal_width = 80
1413
"""The default terminal width for ttys.
1415
This is defined so that higher levels can share a common fallback value when
1416
terminal_width() returns None.
1419
# Keep some state so that terminal_width can detect if _terminal_size has
1420
# returned a different size since the process started. See docstring and
1421
# comments of terminal_width for details.
1422
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1423
_terminal_size_state = 'no_data'
1424
_first_terminal_size = None
1241
1426
def terminal_width():
1242
"""Return estimated terminal width."""
1243
if sys.platform == 'win32':
1244
return win32utils.get_console_size()[0]
1427
"""Return terminal width.
1429
None is returned if the width can't established precisely.
1432
- if BZR_COLUMNS is set, returns its value
1433
- if there is no controlling terminal, returns None
1434
- query the OS, if the queried size has changed since the last query,
1436
- if COLUMNS is set, returns its value,
1437
- if the OS has a value (even though it's never changed), return its value.
1439
From there, we need to query the OS to get the size of the controlling
1442
On Unices we query the OS by:
1443
- get termios.TIOCGWINSZ
1444
- if an error occurs or a negative value is obtained, returns None
1446
On Windows we query the OS by:
1447
- win32utils.get_console_size() decides,
1448
- returns None on error (provided default value)
1450
# Note to implementors: if changing the rules for determining the width,
1451
# make sure you've considered the behaviour in these cases:
1452
# - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1453
# - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1455
# - (add more interesting cases here, if you find any)
1456
# Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1457
# but we don't want to register a signal handler because it is impossible
1458
# to do so without risking EINTR errors in Python <= 2.6.5 (see
1459
# <http://bugs.python.org/issue8354>). Instead we check TIOCGWINSZ every
1460
# time so we can notice if the reported size has changed, which should have
1463
# If BZR_COLUMNS is set, take it, user is always right
1464
# Except if they specified 0 in which case, impose no limit here
1466
width = int(os.environ['BZR_COLUMNS'])
1467
except (KeyError, ValueError):
1469
if width is not None:
1475
isatty = getattr(sys.stdout, 'isatty', None)
1476
if isatty is None or not isatty():
1477
# Don't guess, setting BZR_COLUMNS is the recommended way to override.
1481
width, height = os_size = _terminal_size(None, None)
1482
global _first_terminal_size, _terminal_size_state
1483
if _terminal_size_state == 'no_data':
1484
_first_terminal_size = os_size
1485
_terminal_size_state = 'unchanged'
1486
elif (_terminal_size_state == 'unchanged' and
1487
_first_terminal_size != os_size):
1488
_terminal_size_state = 'changed'
1490
# If the OS claims to know how wide the terminal is, and this value has
1491
# ever changed, use that.
1492
if _terminal_size_state == 'changed':
1493
if width is not None and width > 0:
1496
# If COLUMNS is set, use it.
1498
return int(os.environ['COLUMNS'])
1499
except (KeyError, ValueError):
1502
# Finally, use an unchanged size from the OS, if we have one.
1503
if _terminal_size_state == 'unchanged':
1504
if width is not None and width > 0:
1507
# The width could not be determined.
1511
def _win32_terminal_size(width, height):
1512
width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
1513
return width, height
1516
def _ioctl_terminal_size(width, height):
1247
1518
import struct, fcntl, termios
1248
1519
s = struct.pack('HHHH', 0, 0, 0, 0)
1249
1520
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1250
width = struct.unpack('HHHH', x)[1]
1521
height, width = struct.unpack('HHHH', x)[0:2]
1522
except (IOError, AttributeError):
1255
width = int(os.environ['COLUMNS'])
1524
return width, height
1526
_terminal_size = None
1527
"""Returns the terminal size as (width, height).
1529
:param width: Default value for width.
1530
:param height: Default value for height.
1532
This is defined specifically for each OS and query the size of the controlling
1533
terminal. If any error occurs, the provided default values should be returned.
1535
if sys.platform == 'win32':
1536
_terminal_size = _win32_terminal_size
1538
_terminal_size = _ioctl_terminal_size
1264
1541
def supports_executable():
1688
1995
return socket.gethostname().decode(get_user_encoding())
1691
def recv_all(socket, bytes):
1998
# We must not read/write any more than 64k at a time from/to a socket so we
1999
# don't risk "no buffer space available" errors on some platforms. Windows in
2000
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
2002
MAX_SOCKET_CHUNK = 64 * 1024
2004
_end_of_stream_errors = [errno.ECONNRESET]
2005
for _eno in ['WSAECONNRESET', 'WSAECONNABORTED']:
2006
_eno = getattr(errno, _eno, None)
2007
if _eno is not None:
2008
_end_of_stream_errors.append(_eno)
2012
def read_bytes_from_socket(sock, report_activity=None,
2013
max_read_size=MAX_SOCKET_CHUNK):
2014
"""Read up to max_read_size of bytes from sock and notify of progress.
2016
Translates "Connection reset by peer" into file-like EOF (return an
2017
empty string rather than raise an error), and repeats the recv if
2018
interrupted by a signal.
2022
bytes = sock.recv(max_read_size)
2023
except socket.error, e:
2025
if eno in _end_of_stream_errors:
2026
# The connection was closed by the other side. Callers expect
2027
# an empty string to signal end-of-stream.
2029
elif eno == errno.EINTR:
2030
# Retry the interrupted recv.
2034
if report_activity is not None:
2035
report_activity(len(bytes), 'read')
2039
def recv_all(socket, count):
1692
2040
"""Receive an exact number of bytes.
1694
2042
Regular Socket.recv() may return less than the requested number of bytes,
1695
dependning on what's in the OS buffer. MSG_WAITALL is not available
2043
depending on what's in the OS buffer. MSG_WAITALL is not available
1696
2044
on all platforms, but this should work everywhere. This will return
1697
2045
less than the requested amount if the remote end closes.
1699
2047
This isn't optimized and is intended mostly for use in testing.
1702
while len(b) < bytes:
1703
new = until_no_eintr(socket.recv, bytes - len(b))
2050
while len(b) < count:
2051
new = read_bytes_from_socket(socket, None, count - len(b))
1710
def send_all(socket, bytes, report_activity=None):
2058
def send_all(sock, bytes, report_activity=None):
1711
2059
"""Send all bytes on a socket.
1713
Regular socket.sendall() can give socket error 10053 on Windows. This
1714
implementation sends no more than 64k at a time, which avoids this problem.
2061
Breaks large blocks in smaller chunks to avoid buffering limitations on
2062
some platforms, and catches EINTR which may be thrown if the send is
2063
interrupted by a signal.
2065
This is preferred to socket.sendall(), because it avoids portability bugs
2066
and provides activity reporting.
1716
2068
:param report_activity: Call this as bytes are read, see
1717
2069
Transport._report_activity
1720
for pos in xrange(0, len(bytes), chunk_size):
1721
block = bytes[pos:pos+chunk_size]
1722
if report_activity is not None:
1723
report_activity(len(block), 'write')
1724
until_no_eintr(socket.sendall, block)
2072
byte_count = len(bytes)
2073
while sent_total < byte_count:
2075
sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2076
except socket.error, e:
2077
if e.args[0] != errno.EINTR:
2081
report_activity(sent, 'write')
2084
def connect_socket(address):
2085
# Slight variation of the socket.create_connection() function (provided by
2086
# python-2.6) that can fail if getaddrinfo returns an empty list. We also
2087
# provide it for previous python versions. Also, we don't use the timeout
2088
# parameter (provided by the python implementation) so we don't implement
2090
err = socket.error('getaddrinfo returns an empty list')
2091
host, port = address
2092
for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
2093
af, socktype, proto, canonname, sa = res
2096
sock = socket.socket(af, socktype, proto)
2100
except socket.error, err:
2101
# 'err' is now the most recent error
2102
if sock is not None:
1727
2107
def dereference_path(path):
1901
2301
_cached_concurrency = concurrency
1902
2302
return concurrency
2305
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
2306
"""A stream writer that doesn't decode str arguments."""
2308
def __init__(self, encode, stream, errors='strict'):
2309
codecs.StreamWriter.__init__(self, stream, errors)
2310
self.encode = encode
2312
def write(self, object):
2313
if type(object) is str:
2314
self.stream.write(object)
2316
data, _ = self.encode(object, self.errors)
2317
self.stream.write(data)
2319
if sys.platform == 'win32':
2320
def open_file(filename, mode='r', bufsize=-1):
2321
"""This function is used to override the ``open`` builtin.
2323
But it uses O_NOINHERIT flag so the file handle is not inherited by
2324
child processes. Deleting or renaming a closed file opened with this
2325
function is not blocking child processes.
2327
writing = 'w' in mode
2328
appending = 'a' in mode
2329
updating = '+' in mode
2330
binary = 'b' in mode
2333
# see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
2334
# for flags for each modes.
2344
flags |= os.O_WRONLY
2345
flags |= os.O_CREAT | os.O_TRUNC
2350
flags |= os.O_WRONLY
2351
flags |= os.O_CREAT | os.O_APPEND
2356
flags |= os.O_RDONLY
2358
return os.fdopen(os.open(filename, flags), mode, bufsize)
2363
def getuser_unicode():
2364
"""Return the username as unicode.
2367
user_encoding = get_user_encoding()
2368
username = getpass.getuser().decode(user_encoding)
2369
except UnicodeDecodeError:
2370
raise errors.BzrError("Can't decode username as %s." % \
2372
except ImportError, e:
2373
if sys.platform != 'win32':
2375
if str(e) != 'No module named pwd':
2377
# https://bugs.launchpad.net/bzr/+bug/660174
2378
# getpass.getuser() is unable to return username on Windows
2379
# if there is no USERNAME environment variable set.
2380
# That could be true if bzr is running as a service,
2381
# e.g. running `bzr serve` as a service on Windows.
2382
# We should not fail with traceback in this case.
2383
username = u'UNKNOWN'
2387
def available_backup_name(base, exists):
2388
"""Find a non-existing backup file name.
2390
This will *not* create anything, this only return a 'free' entry. This
2391
should be used for checking names in a directory below a locked
2392
tree/branch/repo to avoid race conditions. This is LBYL (Look Before You
2393
Leap) and generally discouraged.
2395
:param base: The base name.
2397
:param exists: A callable returning True if the path parameter exists.
2400
name = "%s.~%d~" % (base, counter)
2403
name = "%s.~%d~" % (base, counter)
2407
def set_fd_cloexec(fd):
2408
"""Set a Unix file descriptor's FD_CLOEXEC flag. Do nothing if platform
2409
support for this is not available.
2413
old = fcntl.fcntl(fd, fcntl.F_GETFD)
2414
fcntl.fcntl(fd, fcntl.F_SETFD, old | fcntl.FD_CLOEXEC)
2415
except (ImportError, AttributeError):
2416
# Either the fcntl module or specific constants are not present
added
removed
bzrlib/osutils.py
