69
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
72
89
# On win32, O_BINARY is used to indicate the file should
73
90
# be opened in binary mode, rather than text mode.
74
91
# On other platforms, O_BINARY doesn't exist, because
75
92
# they always open in binary mode, so it is okay to
76
# OR with 0 on those platforms
93
# OR with 0 on those platforms.
94
# O_NOINHERIT and O_TEXT exists only on win32 too.
77
95
O_BINARY = getattr(os, 'O_BINARY', 0)
96
O_TEXT = getattr(os, 'O_TEXT', 0)
97
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
100
def get_unicode_argv():
102
user_encoding = get_user_encoding()
103
return [a.decode(user_encoding) for a in sys.argv[1:]]
104
except UnicodeDecodeError:
105
raise errors.BzrError(("Parameter '%r' is unsupported by the current "
80
109
def make_readonly(filename):
847
936
return pathjoin(*p)
939
def parent_directories(filename):
940
"""Return the list of parent directories, deepest first.
942
For example, parent_directories("a/b/c") -> ["a/b", "a"].
945
parts = splitpath(dirname(filename))
947
parents.append(joinpath(parts))
952
_extension_load_failures = []
955
def failed_to_load_extension(exception):
956
"""Handle failing to load a binary extension.
958
This should be called from the ImportError block guarding the attempt to
959
import the native extension. If this function returns, the pure-Python
960
implementation should be loaded instead::
963
>>> import bzrlib._fictional_extension_pyx
964
>>> except ImportError, e:
965
>>> bzrlib.osutils.failed_to_load_extension(e)
966
>>> import bzrlib._fictional_extension_py
968
# NB: This docstring is just an example, not a doctest, because doctest
969
# currently can't cope with the use of lazy imports in this namespace --
972
# This currently doesn't report the failure at the time it occurs, because
973
# they tend to happen very early in startup when we can't check config
974
# files etc, and also we want to report all failures but not spam the user
976
from bzrlib import trace
977
exception_str = str(exception)
978
if exception_str not in _extension_load_failures:
979
trace.mutter("failed to load compiled extension: %s" % exception_str)
980
_extension_load_failures.append(exception_str)
983
def report_extension_load_failures():
984
if not _extension_load_failures:
986
from bzrlib.config import GlobalConfig
987
if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
989
# the warnings framework should by default show this only once
990
from bzrlib.trace import warning
992
"bzr: warning: some compiled extensions could not be loaded; "
993
"see <https://answers.launchpad.net/bzr/+faq/703>")
994
# we no longer show the specific missing extensions here, because it makes
995
# the message too long and scary - see
996
# https://bugs.launchpad.net/bzr/+bug/430529
851
1000
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1001
except ImportError, e:
1002
failed_to_load_extension(e)
853
1003
from bzrlib._chunks_to_lines_py import chunks_to_lines
893
1043
shutil.copyfile(src, dest)
896
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
897
# Forgiveness than Permission (EAFP) because:
898
# - root can damage a solaris file system by using unlink,
899
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
900
# EACCES, OSX: EPERM) when invoked on a directory.
901
1046
def delete_any(path):
902
"""Delete a file or directory."""
1047
"""Delete a file, symlink or directory.
1049
Will delete even if readonly.
1052
_delete_file_or_dir(path)
1053
except (OSError, IOError), e:
1054
if e.errno in (errno.EPERM, errno.EACCES):
1055
# make writable and try again
1058
except (OSError, IOError):
1060
_delete_file_or_dir(path)
1065
def _delete_file_or_dir(path):
1066
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
1067
# Forgiveness than Permission (EAFP) because:
1068
# - root can damage a solaris file system by using unlink,
1069
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1070
# EACCES, OSX: EPERM) when invoked on a directory.
903
1071
if isdir(path): # Takes care of symlinks
1047
1240
# but for now, we haven't optimized...
1048
1241
return [canonical_relpath(base, p) for p in paths]
1244
def decode_filename(filename):
1245
"""Decode the filename using the filesystem encoding
1247
If it is unicode, it is returned.
1248
Otherwise it is decoded from the the filesystem's encoding. If decoding
1249
fails, a errors.BadFilenameEncoding exception is raised.
1251
if type(filename) is unicode:
1254
return filename.decode(_fs_enc)
1255
except UnicodeDecodeError:
1256
raise errors.BadFilenameEncoding(filename, _fs_enc)
1050
1259
def safe_unicode(unicode_or_utf8_string):
1051
1260
"""Coerce unicode_or_utf8_string into unicode.
1053
1262
If it is unicode, it is returned.
1054
Otherwise it is decoded from utf-8. If a decoding error
1055
occurs, it is wrapped as a If the decoding fails, the exception is wrapped
1056
as a BzrBadParameter exception.
1263
Otherwise it is decoded from utf-8. If decoding fails, the exception is
1264
wrapped in a BzrBadParameterNotUnicode exception.
1058
1266
if isinstance(unicode_or_utf8_string, unicode):
1059
1267
return unicode_or_utf8_string
1172
1380
normalized_filename = _inaccessible_normalized_filename
1383
def set_signal_handler(signum, handler, restart_syscall=True):
1384
"""A wrapper for signal.signal that also calls siginterrupt(signum, False)
1385
on platforms that support that.
1387
:param restart_syscall: if set, allow syscalls interrupted by a signal to
1388
automatically restart (by calling `signal.siginterrupt(signum,
1389
False)`). May be ignored if the feature is not available on this
1390
platform or Python version.
1394
siginterrupt = signal.siginterrupt
1396
# This python implementation doesn't provide signal support, hence no
1399
except AttributeError:
1400
# siginterrupt doesn't exist on this platform, or for this version
1402
siginterrupt = lambda signum, flag: None
1404
def sig_handler(*args):
1405
# Python resets the siginterrupt flag when a signal is
1406
# received. <http://bugs.python.org/issue8354>
1407
# As a workaround for some cases, set it back the way we want it.
1408
siginterrupt(signum, False)
1409
# Now run the handler function passed to set_signal_handler.
1412
sig_handler = handler
1413
old_handler = signal.signal(signum, sig_handler)
1415
siginterrupt(signum, False)
1419
default_terminal_width = 80
1420
"""The default terminal width for ttys.
1422
This is defined so that higher levels can share a common fallback value when
1423
terminal_width() returns None.
1426
# Keep some state so that terminal_width can detect if _terminal_size has
1427
# returned a different size since the process started. See docstring and
1428
# comments of terminal_width for details.
1429
# _terminal_size_state has 3 possible values: no_data, unchanged, and changed.
1430
_terminal_size_state = 'no_data'
1431
_first_terminal_size = None
1175
1433
def terminal_width():
1176
"""Return estimated terminal width."""
1177
if sys.platform == 'win32':
1178
return win32utils.get_console_size()[0]
1434
"""Return terminal width.
1436
None is returned if the width can't established precisely.
1439
- if BZR_COLUMNS is set, returns its value
1440
- if there is no controlling terminal, returns None
1441
- query the OS, if the queried size has changed since the last query,
1443
- if COLUMNS is set, returns its value,
1444
- if the OS has a value (even though it's never changed), return its value.
1446
From there, we need to query the OS to get the size of the controlling
1449
On Unices we query the OS by:
1450
- get termios.TIOCGWINSZ
1451
- if an error occurs or a negative value is obtained, returns None
1453
On Windows we query the OS by:
1454
- win32utils.get_console_size() decides,
1455
- returns None on error (provided default value)
1457
# Note to implementors: if changing the rules for determining the width,
1458
# make sure you've considered the behaviour in these cases:
1459
# - M-x shell in emacs, where $COLUMNS is set and TIOCGWINSZ returns 0,0.
1460
# - bzr log | less, in bash, where $COLUMNS not set and TIOCGWINSZ returns
1462
# - (add more interesting cases here, if you find any)
1463
# Some programs implement "Use $COLUMNS (if set) until SIGWINCH occurs",
1464
# but we don't want to register a signal handler because it is impossible
1465
# to do so without risking EINTR errors in Python <= 2.6.5 (see
1466
# <http://bugs.python.org/issue8354>). Instead we check TIOCGWINSZ every
1467
# time so we can notice if the reported size has changed, which should have
1470
# If BZR_COLUMNS is set, take it, user is always right
1472
return int(os.environ['BZR_COLUMNS'])
1473
except (KeyError, ValueError):
1476
isatty = getattr(sys.stdout, 'isatty', None)
1477
if isatty is None or not isatty():
1478
# Don't guess, setting BZR_COLUMNS is the recommended way to override.
1482
width, height = os_size = _terminal_size(None, None)
1483
global _first_terminal_size, _terminal_size_state
1484
if _terminal_size_state == 'no_data':
1485
_first_terminal_size = os_size
1486
_terminal_size_state = 'unchanged'
1487
elif (_terminal_size_state == 'unchanged' and
1488
_first_terminal_size != os_size):
1489
_terminal_size_state = 'changed'
1491
# If the OS claims to know how wide the terminal is, and this value has
1492
# ever changed, use that.
1493
if _terminal_size_state == 'changed':
1494
if width is not None and width > 0:
1497
# If COLUMNS is set, use it.
1499
return int(os.environ['COLUMNS'])
1500
except (KeyError, ValueError):
1503
# Finally, use an unchanged size from the OS, if we have one.
1504
if _terminal_size_state == 'unchanged':
1505
if width is not None and width > 0:
1508
# The width could not be determined.
1512
def _win32_terminal_size(width, height):
1513
width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
1514
return width, height
1517
def _ioctl_terminal_size(width, height):
1181
1519
import struct, fcntl, termios
1182
1520
s = struct.pack('HHHH', 0, 0, 0, 0)
1183
1521
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1184
width = struct.unpack('HHHH', x)[1]
1522
height, width = struct.unpack('HHHH', x)[0:2]
1523
except (IOError, AttributeError):
1189
width = int(os.environ['COLUMNS'])
1525
return width, height
1527
_terminal_size = None
1528
"""Returns the terminal size as (width, height).
1530
:param width: Default value for width.
1531
:param height: Default value for height.
1533
This is defined specifically for each OS and query the size of the controlling
1534
terminal. If any error occurs, the provided default values should be returned.
1536
if sys.platform == 'win32':
1537
_terminal_size = _win32_terminal_size
1539
_terminal_size = _ioctl_terminal_size
1198
1542
def supports_executable():
1622
1993
return socket.gethostname().decode(get_user_encoding())
1625
def recv_all(socket, bytes):
1996
# We must not read/write any more than 64k at a time from/to a socket so we
1997
# don't risk "no buffer space available" errors on some platforms. Windows in
1998
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
2000
MAX_SOCKET_CHUNK = 64 * 1024
2002
def read_bytes_from_socket(sock, report_activity=None,
2003
max_read_size=MAX_SOCKET_CHUNK):
2004
"""Read up to max_read_size of bytes from sock and notify of progress.
2006
Translates "Connection reset by peer" into file-like EOF (return an
2007
empty string rather than raise an error), and repeats the recv if
2008
interrupted by a signal.
2012
bytes = sock.recv(max_read_size)
2013
except socket.error, e:
2015
if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
2016
# The connection was closed by the other side. Callers expect
2017
# an empty string to signal end-of-stream.
2019
elif eno == errno.EINTR:
2020
# Retry the interrupted recv.
2024
if report_activity is not None:
2025
report_activity(len(bytes), 'read')
2029
def recv_all(socket, count):
1626
2030
"""Receive an exact number of bytes.
1628
2032
Regular Socket.recv() may return less than the requested number of bytes,
1629
dependning on what's in the OS buffer. MSG_WAITALL is not available
2033
depending on what's in the OS buffer. MSG_WAITALL is not available
1630
2034
on all platforms, but this should work everywhere. This will return
1631
2035
less than the requested amount if the remote end closes.
1633
2037
This isn't optimized and is intended mostly for use in testing.
1636
while len(b) < bytes:
1637
new = until_no_eintr(socket.recv, bytes - len(b))
2040
while len(b) < count:
2041
new = read_bytes_from_socket(socket, None, count - len(b))
1644
def send_all(socket, bytes, report_activity=None):
2048
def send_all(sock, bytes, report_activity=None):
1645
2049
"""Send all bytes on a socket.
1647
Regular socket.sendall() can give socket error 10053 on Windows. This
1648
implementation sends no more than 64k at a time, which avoids this problem.
2051
Breaks large blocks in smaller chunks to avoid buffering limitations on
2052
some platforms, and catches EINTR which may be thrown if the send is
2053
interrupted by a signal.
2055
This is preferred to socket.sendall(), because it avoids portability bugs
2056
and provides activity reporting.
1650
2058
:param report_activity: Call this as bytes are read, see
1651
2059
Transport._report_activity
1654
for pos in xrange(0, len(bytes), chunk_size):
1655
block = bytes[pos:pos+chunk_size]
1656
if report_activity is not None:
1657
report_activity(len(block), 'write')
1658
until_no_eintr(socket.sendall, block)
2062
byte_count = len(bytes)
2063
while sent_total < byte_count:
2065
sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2066
except socket.error, e:
2067
if e.args[0] != errno.EINTR:
2071
report_activity(sent, 'write')
1661
2074
def dereference_path(path):
1780
2209
termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2213
if sys.platform == 'linux2':
2214
def _local_concurrency():
2216
prefix = 'processor'
2217
for line in file('/proc/cpuinfo', 'rb'):
2218
if line.startswith(prefix):
2219
concurrency = int(line[line.find(':')+1:]) + 1
2221
elif sys.platform == 'darwin':
2222
def _local_concurrency():
2223
return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2224
stdout=subprocess.PIPE).communicate()[0]
2225
elif sys.platform[0:7] == 'freebsd':
2226
def _local_concurrency():
2227
return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2228
stdout=subprocess.PIPE).communicate()[0]
2229
elif sys.platform == 'sunos5':
2230
def _local_concurrency():
2231
return subprocess.Popen(['psrinfo', '-p',],
2232
stdout=subprocess.PIPE).communicate()[0]
2233
elif sys.platform == "win32":
2234
def _local_concurrency():
2235
# This appears to return the number of cores.
2236
return os.environ.get('NUMBER_OF_PROCESSORS')
2238
def _local_concurrency():
2243
_cached_local_concurrency = None
2245
def local_concurrency(use_cache=True):
2246
"""Return how many processes can be run concurrently.
2248
Rely on platform specific implementations and default to 1 (one) if
2249
anything goes wrong.
2251
global _cached_local_concurrency
2253
if _cached_local_concurrency is not None and use_cache:
2254
return _cached_local_concurrency
2256
concurrency = os.environ.get('BZR_CONCURRENCY', None)
2257
if concurrency is None:
2259
concurrency = _local_concurrency()
2260
except (OSError, IOError):
2263
concurrency = int(concurrency)
2264
except (TypeError, ValueError):
2267
_cached_concurrency = concurrency
2271
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
2272
"""A stream writer that doesn't decode str arguments."""
2274
def __init__(self, encode, stream, errors='strict'):
2275
codecs.StreamWriter.__init__(self, stream, errors)
2276
self.encode = encode
2278
def write(self, object):
2279
if type(object) is str:
2280
self.stream.write(object)
2282
data, _ = self.encode(object, self.errors)
2283
self.stream.write(data)
2285
if sys.platform == 'win32':
2286
def open_file(filename, mode='r', bufsize=-1):
2287
"""This function is used to override the ``open`` builtin.
2289
But it uses O_NOINHERIT flag so the file handle is not inherited by
2290
child processes. Deleting or renaming a closed file opened with this
2291
function is not blocking child processes.
2293
writing = 'w' in mode
2294
appending = 'a' in mode
2295
updating = '+' in mode
2296
binary = 'b' in mode
2299
# see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
2300
# for flags for each modes.
2310
flags |= os.O_WRONLY
2311
flags |= os.O_CREAT | os.O_TRUNC
2316
flags |= os.O_WRONLY
2317
flags |= os.O_CREAT | os.O_APPEND
2322
flags |= os.O_RDONLY
2324
return os.fdopen(os.open(filename, flags), mode, bufsize)
2329
def getuser_unicode():
2330
"""Return the username as unicode.
2333
user_encoding = get_user_encoding()
2334
username = getpass.getuser().decode(user_encoding)
2335
except UnicodeDecodeError:
2336
raise errors.BzrError("Can't decode username as %s." % \
added
removed
bzrlib/osutils.py
