70
77
from bzrlib import symbol_versioning
80
# Cross platform wall-clock time functionality with decent resolution.
81
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
82
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
83
# synchronized with ``time.time()``, this is only meant to be used to find
84
# delta times by subtracting from another call to this function.
85
timer_func = time.time
86
if sys.platform == 'win32':
87
timer_func = time.clock
73
89
# On win32, O_BINARY is used to indicate the file should
74
90
# be opened in binary mode, rather than text mode.
75
91
# On other platforms, O_BINARY doesn't exist, because
76
92
# they always open in binary mode, so it is okay to
77
# OR with 0 on those platforms
93
# OR with 0 on those platforms.
94
# O_NOINHERIT and O_TEXT exists only on win32 too.
78
95
O_BINARY = getattr(os, 'O_BINARY', 0)
96
O_TEXT = getattr(os, 'O_TEXT', 0)
97
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
81
100
def get_unicode_argv():
191
212
:param old: The old path, to rename from
192
213
:param new: The new path, to rename to
193
214
:param rename_func: The potentially non-atomic rename function
194
:param unlink_func: A way to delete the target file if the full rename succeeds
215
:param unlink_func: A way to delete the target file if the full rename
197
218
# sftp rename doesn't allow overwriting, so play tricks:
198
219
base = os.path.basename(new)
199
220
dirname = os.path.dirname(new)
200
tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
221
# callers use different encodings for the paths so the following MUST
222
# respect that. We rely on python upcasting to unicode if new is unicode
223
# and keeping a str if not.
224
tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
225
os.getpid(), rand_chars(10))
201
226
tmp_name = pathjoin(dirname, tmp_name)
203
228
# Rename the file out of the way, but keep track if it didn't exist
706
758
date_str = time.strftime(date_fmt, tt)
707
759
return date_str + offset_str
762
# Cache of formatted offset strings
766
def format_date_with_offset_in_original_timezone(t, offset=0,
767
_cache=_offset_cache):
768
"""Return a formatted date string in the original timezone.
770
This routine may be faster then format_date.
772
:param t: Seconds since the epoch.
773
:param offset: Timezone offset in seconds east of utc.
777
tt = time.gmtime(t + offset)
778
date_fmt = _default_format_by_weekday_num[tt[6]]
779
date_str = time.strftime(date_fmt, tt)
780
offset_str = _cache.get(offset, None)
781
if offset_str is None:
782
offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
783
_cache[offset] = offset_str
784
return date_str + offset_str
709
787
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
710
788
show_offset=True):
711
789
"""Return an unicode date string formatted according to the current locale.
963
_extension_load_failures = []
966
def failed_to_load_extension(exception):
967
"""Handle failing to load a binary extension.
969
This should be called from the ImportError block guarding the attempt to
970
import the native extension. If this function returns, the pure-Python
971
implementation should be loaded instead::
974
>>> import bzrlib._fictional_extension_pyx
975
>>> except ImportError, e:
976
>>> bzrlib.osutils.failed_to_load_extension(e)
977
>>> import bzrlib._fictional_extension_py
979
# NB: This docstring is just an example, not a doctest, because doctest
980
# currently can't cope with the use of lazy imports in this namespace --
983
# This currently doesn't report the failure at the time it occurs, because
984
# they tend to happen very early in startup when we can't check config
985
# files etc, and also we want to report all failures but not spam the user
987
from bzrlib import trace
988
exception_str = str(exception)
989
if exception_str not in _extension_load_failures:
990
trace.mutter("failed to load compiled extension: %s" % exception_str)
991
_extension_load_failures.append(exception_str)
994
def report_extension_load_failures():
995
if not _extension_load_failures:
997
from bzrlib.config import GlobalConfig
998
if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
1000
# the warnings framework should by default show this only once
1001
from bzrlib.trace import warning
1003
"bzr: warning: some compiled extensions could not be loaded; "
1004
"see <https://answers.launchpad.net/bzr/+faq/703>")
1005
# we no longer show the specific missing extensions here, because it makes
1006
# the message too long and scary - see
1007
# https://bugs.launchpad.net/bzr/+bug/430529
885
1011
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1012
except ImportError, e:
1013
failed_to_load_extension(e)
887
1014
from bzrlib._chunks_to_lines_py import chunks_to_lines
1238
1375
normalized_filename = _inaccessible_normalized_filename
1378
def set_signal_handler(signum, handler, restart_syscall=True):
1379
"""A wrapper for signal.signal that also calls siginterrupt(signum, False)
1380
on platforms that support that.
1382
:param restart_syscall: if set, allow syscalls interrupted by a signal to
1383
automatically restart (by calling `signal.siginterrupt(signum,
1384
False)`). May be ignored if the feature is not available on this
1385
platform or Python version.
1389
siginterrupt = signal.siginterrupt
1391
# This python implementation doesn't provide signal support, hence no
1394
except AttributeError:
1395
# siginterrupt doesn't exist on this platform, or for this version
1397
siginterrupt = lambda signum, flag: None
1399
def sig_handler(*args):
1400
# Python resets the siginterrupt flag when a signal is
1401
# received. <http://bugs.python.org/issue8354>
1402
# As a workaround for some cases, set it back the way we want it.
1403
siginterrupt(signum, False)
1404
# Now run the handler function passed to set_signal_handler.
1407
sig_handler = handler
1408
old_handler = signal.signal(signum, sig_handler)
1410
siginterrupt(signum, False)
1414
default_terminal_width = 80
1415
"""The default terminal width for ttys.
1417
This is defined so that higher levels can share a common fallback value when
1418
terminal_width() returns None.
1241
1422
def terminal_width():
1242
"""Return estimated terminal width."""
1243
if sys.platform == 'win32':
1244
return win32utils.get_console_size()[0]
1423
"""Return terminal width.
1425
None is returned if the width can't established precisely.
1428
- if BZR_COLUMNS is set, returns its value
1429
- if there is no controlling terminal, returns None
1430
- if COLUMNS is set, returns its value,
1432
From there, we need to query the OS to get the size of the controlling
1436
- get termios.TIOCGWINSZ
1437
- if an error occurs or a negative value is obtained, returns None
1441
- win32utils.get_console_size() decides,
1442
- returns None on error (provided default value)
1445
# If BZR_COLUMNS is set, take it, user is always right
1447
return int(os.environ['BZR_COLUMNS'])
1448
except (KeyError, ValueError):
1451
isatty = getattr(sys.stdout, 'isatty', None)
1452
if isatty is None or not isatty():
1453
# Don't guess, setting BZR_COLUMNS is the recommended way to override.
1456
# If COLUMNS is set, take it, the terminal knows better (even inside a
1457
# given terminal, the application can decide to set COLUMNS to a lower
1458
# value (splitted screen) or a bigger value (scroll bars))
1460
return int(os.environ['COLUMNS'])
1461
except (KeyError, ValueError):
1464
width, height = _terminal_size(None, None)
1466
# Consider invalid values as meaning no width
1472
def _win32_terminal_size(width, height):
1473
width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
1474
return width, height
1477
def _ioctl_terminal_size(width, height):
1247
1479
import struct, fcntl, termios
1248
1480
s = struct.pack('HHHH', 0, 0, 0, 0)
1249
1481
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1250
width = struct.unpack('HHHH', x)[1]
1482
height, width = struct.unpack('HHHH', x)[0:2]
1483
except (IOError, AttributeError):
1485
return width, height
1487
_terminal_size = None
1488
"""Returns the terminal size as (width, height).
1490
:param width: Default value for width.
1491
:param height: Default value for height.
1493
This is defined specifically for each OS and query the size of the controlling
1494
terminal. If any error occurs, the provided default values should be returned.
1496
if sys.platform == 'win32':
1497
_terminal_size = _win32_terminal_size
1499
_terminal_size = _ioctl_terminal_size
1502
def _terminal_size_changed(signum, frame):
1503
"""Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
1504
width, height = _terminal_size(None, None)
1505
if width is not None:
1506
os.environ['COLUMNS'] = str(width)
1509
_registered_sigwinch = False
1510
def watch_sigwinch():
1511
"""Register for SIGWINCH, once and only once.
1513
Do nothing if the signal module is not available.
1515
global _registered_sigwinch
1516
if not _registered_sigwinch:
1255
width = int(os.environ['COLUMNS'])
1519
if getattr(signal, "SIGWINCH", None) is not None:
1520
set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1522
# python doesn't provide signal support, nothing we can do about it
1524
_registered_sigwinch = True
1264
1527
def supports_executable():
1688
1974
return socket.gethostname().decode(get_user_encoding())
1691
def recv_all(socket, bytes):
1977
# We must not read/write any more than 64k at a time from/to a socket so we
1978
# don't risk "no buffer space available" errors on some platforms. Windows in
1979
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
1981
MAX_SOCKET_CHUNK = 64 * 1024
1983
def read_bytes_from_socket(sock, report_activity=None,
1984
max_read_size=MAX_SOCKET_CHUNK):
1985
"""Read up to max_read_size of bytes from sock and notify of progress.
1987
Translates "Connection reset by peer" into file-like EOF (return an
1988
empty string rather than raise an error), and repeats the recv if
1989
interrupted by a signal.
1993
bytes = sock.recv(max_read_size)
1994
except socket.error, e:
1996
if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
1997
# The connection was closed by the other side. Callers expect
1998
# an empty string to signal end-of-stream.
2000
elif eno == errno.EINTR:
2001
# Retry the interrupted recv.
2005
if report_activity is not None:
2006
report_activity(len(bytes), 'read')
2010
def recv_all(socket, count):
1692
2011
"""Receive an exact number of bytes.
1694
2013
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
2014
depending on what's in the OS buffer. MSG_WAITALL is not available
1696
2015
on all platforms, but this should work everywhere. This will return
1697
2016
less than the requested amount if the remote end closes.
1699
2018
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))
2021
while len(b) < count:
2022
new = read_bytes_from_socket(socket, None, count - len(b))
1710
def send_all(socket, bytes, report_activity=None):
2029
def send_all(sock, bytes, report_activity=None):
1711
2030
"""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.
2032
Breaks large blocks in smaller chunks to avoid buffering limitations on
2033
some platforms, and catches EINTR which may be thrown if the send is
2034
interrupted by a signal.
2036
This is preferred to socket.sendall(), because it avoids portability bugs
2037
and provides activity reporting.
1716
2039
:param report_activity: Call this as bytes are read, see
1717
2040
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)
2043
byte_count = len(bytes)
2044
while sent_total < byte_count:
2046
sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2047
except socket.error, e:
2048
if e.args[0] != errno.EINTR:
2052
report_activity(sent, 'write')
1727
2055
def dereference_path(path):
1901
2246
_cached_concurrency = concurrency
1902
2247
return concurrency
2250
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
2251
"""A stream writer that doesn't decode str arguments."""
2253
def __init__(self, encode, stream, errors='strict'):
2254
codecs.StreamWriter.__init__(self, stream, errors)
2255
self.encode = encode
2257
def write(self, object):
2258
if type(object) is str:
2259
self.stream.write(object)
2261
data, _ = self.encode(object, self.errors)
2262
self.stream.write(data)
2264
if sys.platform == 'win32':
2265
def open_file(filename, mode='r', bufsize=-1):
2266
"""This function is used to override the ``open`` builtin.
2268
But it uses O_NOINHERIT flag so the file handle is not inherited by
2269
child processes. Deleting or renaming a closed file opened with this
2270
function is not blocking child processes.
2272
writing = 'w' in mode
2273
appending = 'a' in mode
2274
updating = '+' in mode
2275
binary = 'b' in mode
2278
# see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
2279
# for flags for each modes.
2289
flags |= os.O_WRONLY
2290
flags |= os.O_CREAT | os.O_TRUNC
2295
flags |= os.O_WRONLY
2296
flags |= os.O_CREAT | os.O_APPEND
2301
flags |= os.O_RDONLY
2303
return os.fdopen(os.open(filename, flags), mode, bufsize)
2308
def getuser_unicode():
2309
"""Return the username as unicode.
2312
user_encoding = get_user_encoding()
2313
username = getpass.getuser().decode(user_encoding)
2314
except UnicodeDecodeError:
2315
raise errors.BzrError("Can't decode username as %s." % \
added
removed
bzrlib/osutils.py
