70
79
from bzrlib import symbol_versioning
71
from bzrlib.symbol_versioning import (
74
from bzrlib.trace import mutter
82
# Cross platform wall-clock time functionality with decent resolution.
83
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
84
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
85
# synchronized with ``time.time()``, this is only meant to be used to find
86
# delta times by subtracting from another call to this function.
87
timer_func = time.time
88
if sys.platform == 'win32':
89
timer_func = time.clock
77
91
# On win32, O_BINARY is used to indicate the file should
78
92
# be opened in binary mode, rather than text mode.
79
93
# On other platforms, O_BINARY doesn't exist, because
80
94
# they always open in binary mode, so it is okay to
81
# OR with 0 on those platforms
95
# OR with 0 on those platforms.
96
# O_NOINHERIT and O_TEXT exists only on win32 too.
82
97
O_BINARY = getattr(os, 'O_BINARY', 0)
98
O_TEXT = getattr(os, 'O_TEXT', 0)
99
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
102
def get_unicode_argv():
104
user_encoding = get_user_encoding()
105
return [a.decode(user_encoding) for a in sys.argv[1:]]
106
except UnicodeDecodeError:
107
raise errors.BzrError(("Parameter '%r' is unsupported by the current "
85
111
def make_readonly(filename):
177
211
def fancy_rename(old, new, rename_func, unlink_func):
178
212
"""A fancy rename, when you don't have atomic rename.
180
214
:param old: The old path, to rename from
181
215
:param new: The new path, to rename to
182
216
:param rename_func: The potentially non-atomic rename function
183
:param unlink_func: A way to delete the target file if the full rename succeeds
217
:param unlink_func: A way to delete the target file if the full rename
186
220
# sftp rename doesn't allow overwriting, so play tricks:
188
221
base = os.path.basename(new)
189
222
dirname = os.path.dirname(new)
190
tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
223
# callers use different encodings for the paths so the following MUST
224
# respect that. We rely on python upcasting to unicode if new is unicode
225
# and keeping a str if not.
226
tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
227
os.getpid(), rand_chars(10))
191
228
tmp_name = pathjoin(dirname, tmp_name)
193
230
# Rename the file out of the way, but keep track if it didn't exist
326
367
"""We expect to be able to atomically replace 'new' with old.
328
369
On win32, if new exists, it must be moved out of the way first,
332
373
fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
333
374
except OSError, e:
334
375
if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
335
# If we try to rename a non-existant file onto cwd, we get
336
# EPERM or EACCES instead of ENOENT, this will raise ENOENT
376
# If we try to rename a non-existant file onto cwd, we get
377
# EPERM or EACCES instead of ENOENT, this will raise ENOENT
337
378
# if the old path doesn't exist, sometimes we get EACCES
338
379
# On Linux, we seem to get EBUSY, on Mac we get EINVAL
652
733
:param timezone: How to display the time: 'utc', 'original' for the
653
734
timezone specified by offset, or 'local' for the process's current
655
:param show_offset: Whether to append the timezone.
656
:param date_fmt: strftime format.
736
:param date_fmt: strftime format.
737
:param show_offset: Whether to append the timezone.
739
(date_fmt, tt, offset_str) = \
740
_format_date(t, offset, timezone, date_fmt, show_offset)
741
date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
742
date_str = time.strftime(date_fmt, tt)
743
return date_str + offset_str
746
# Cache of formatted offset strings
750
def format_date_with_offset_in_original_timezone(t, offset=0,
751
_cache=_offset_cache):
752
"""Return a formatted date string in the original timezone.
754
This routine may be faster then format_date.
756
:param t: Seconds since the epoch.
757
:param offset: Timezone offset in seconds east of utc.
761
tt = time.gmtime(t + offset)
762
date_fmt = _default_format_by_weekday_num[tt[6]]
763
date_str = time.strftime(date_fmt, tt)
764
offset_str = _cache.get(offset, None)
765
if offset_str is None:
766
offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
767
_cache[offset] = offset_str
768
return date_str + offset_str
771
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
773
"""Return an unicode date string formatted according to the current locale.
775
:param t: Seconds since the epoch.
776
:param offset: Timezone offset in seconds east of utc.
777
:param timezone: How to display the time: 'utc', 'original' for the
778
timezone specified by offset, or 'local' for the process's current
780
:param date_fmt: strftime format.
781
:param show_offset: Whether to append the timezone.
783
(date_fmt, tt, offset_str) = \
784
_format_date(t, offset, timezone, date_fmt, show_offset)
785
date_str = time.strftime(date_fmt, tt)
786
if not isinstance(date_str, unicode):
787
date_str = date_str.decode(get_user_encoding(), 'replace')
788
return date_str + offset_str
791
def _format_date(t, offset, timezone, date_fmt, show_offset):
658
792
if timezone == 'utc':
659
793
tt = time.gmtime(t)
798
931
return pathjoin(*p)
934
def parent_directories(filename):
935
"""Return the list of parent directories, deepest first.
937
For example, parent_directories("a/b/c") -> ["a/b", "a"].
940
parts = splitpath(dirname(filename))
942
parents.append(joinpath(parts))
947
_extension_load_failures = []
950
def failed_to_load_extension(exception):
951
"""Handle failing to load a binary extension.
953
This should be called from the ImportError block guarding the attempt to
954
import the native extension. If this function returns, the pure-Python
955
implementation should be loaded instead::
958
>>> import bzrlib._fictional_extension_pyx
959
>>> except ImportError, e:
960
>>> bzrlib.osutils.failed_to_load_extension(e)
961
>>> import bzrlib._fictional_extension_py
963
# NB: This docstring is just an example, not a doctest, because doctest
964
# currently can't cope with the use of lazy imports in this namespace --
967
# This currently doesn't report the failure at the time it occurs, because
968
# they tend to happen very early in startup when we can't check config
969
# files etc, and also we want to report all failures but not spam the user
971
from bzrlib import trace
972
exception_str = str(exception)
973
if exception_str not in _extension_load_failures:
974
trace.mutter("failed to load compiled extension: %s" % exception_str)
975
_extension_load_failures.append(exception_str)
978
def report_extension_load_failures():
979
if not _extension_load_failures:
981
from bzrlib.config import GlobalConfig
982
if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
984
# the warnings framework should by default show this only once
985
from bzrlib.trace import warning
987
"bzr: warning: some compiled extensions could not be loaded; "
988
"see <https://answers.launchpad.net/bzr/+faq/703>")
989
# we no longer show the specific missing extensions here, because it makes
990
# the message too long and scary - see
991
# https://bugs.launchpad.net/bzr/+bug/430529
995
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
996
except ImportError, e:
997
failed_to_load_extension(e)
998
from bzrlib._chunks_to_lines_py import chunks_to_lines
801
1001
def split_lines(s):
802
1002
"""Split s into lines, but without removing the newline characters."""
1003
# Trivially convert a fulltext into a 'chunked' representation, and let
1004
# chunks_to_lines do the heavy lifting.
1005
if isinstance(s, str):
1006
# chunks_to_lines only supports 8-bit strings
1007
return chunks_to_lines([s])
1009
return _split_lines(s)
1012
def _split_lines(s):
1013
"""Split s into lines, but without removing the newline characters.
1015
This supports Unicode or plain string objects.
803
1017
lines = s.split('\n')
804
1018
result = [line + '\n' for line in lines[:-1]]
824
1038
shutil.copyfile(src, dest)
827
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
828
# Forgiveness than Permission (EAFP) because:
829
# - root can damage a solaris file system by using unlink,
830
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
831
# EACCES, OSX: EPERM) when invoked on a directory.
832
1041
def delete_any(path):
833
"""Delete a file or directory."""
1042
"""Delete a file, symlink or directory.
1044
Will delete even if readonly.
1047
_delete_file_or_dir(path)
1048
except (OSError, IOError), e:
1049
if e.errno in (errno.EPERM, errno.EACCES):
1050
# make writable and try again
1053
except (OSError, IOError):
1055
_delete_file_or_dir(path)
1060
def _delete_file_or_dir(path):
1061
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
1062
# Forgiveness than Permission (EAFP) because:
1063
# - root can damage a solaris file system by using unlink,
1064
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1065
# EACCES, OSX: EPERM) when invoked on a directory.
834
1066
if isdir(path): # Takes care of symlinks
908
while len(head) >= len(base):
1155
if len(head) <= len(base) and head != base:
1156
raise errors.PathNotChild(rp, base)
909
1157
if head == base:
911
head, tail = os.path.split(head)
1159
head, tail = split(head)
915
raise errors.PathNotChild(rp, base)
1164
return pathjoin(*reversed(s))
1169
def _cicp_canonical_relpath(base, path):
1170
"""Return the canonical path relative to base.
1172
Like relpath, but on case-insensitive-case-preserving file-systems, this
1173
will return the relpath as stored on the file-system rather than in the
1174
case specified in the input string, for all existing portions of the path.
1176
This will cause O(N) behaviour if called for every path in a tree; if you
1177
have a number of paths to convert, you should use canonical_relpaths().
1179
# TODO: it should be possible to optimize this for Windows by using the
1180
# win32 API FindFiles function to look for the specified name - but using
1181
# os.listdir() still gives us the correct, platform agnostic semantics in
1184
rel = relpath(base, path)
1185
# '.' will have been turned into ''
1189
abs_base = abspath(base)
1191
_listdir = os.listdir
1193
# use an explicit iterator so we can easily consume the rest on early exit.
1194
bit_iter = iter(rel.split('/'))
1195
for bit in bit_iter:
1198
next_entries = _listdir(current)
1199
except OSError: # enoent, eperm, etc
1200
# We can't find this in the filesystem, so just append the
1202
current = pathjoin(current, bit, *list(bit_iter))
1204
for look in next_entries:
1205
if lbit == look.lower():
1206
current = pathjoin(current, look)
1209
# got to the end, nothing matched, so we just return the
1210
# non-existing bits as they were specified (the filename may be
1211
# the target of a move, for example).
1212
current = pathjoin(current, bit, *list(bit_iter))
1214
return current[len(abs_base):].lstrip('/')
1216
# XXX - TODO - we need better detection/integration of case-insensitive
1217
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1218
# filesystems), for example, so could probably benefit from the same basic
1219
# support there. For now though, only Windows and OSX get that support, and
1220
# they get it for *all* file-systems!
1221
if sys.platform in ('win32', 'darwin'):
1222
canonical_relpath = _cicp_canonical_relpath
1224
canonical_relpath = relpath
1226
def canonical_relpaths(base, paths):
1227
"""Create an iterable to canonicalize a sequence of relative paths.
1229
The intent is for this implementation to use a cache, vastly speeding
1230
up multiple transformations in the same directory.
1232
# but for now, we haven't optimized...
1233
return [canonical_relpath(base, p) for p in paths]
923
1235
def safe_unicode(unicode_or_utf8_string):
924
1236
"""Coerce unicode_or_utf8_string into unicode.
926
1238
If it is unicode, it is returned.
927
Otherwise it is decoded from utf-8. If a decoding error
928
occurs, it is wrapped as a If the decoding fails, the exception is wrapped
929
as a BzrBadParameter exception.
1239
Otherwise it is decoded from utf-8. If decoding fails, the exception is
1240
wrapped in a BzrBadParameterNotUnicode exception.
931
1242
if isinstance(unicode_or_utf8_string, unicode):
932
1243
return unicode_or_utf8_string
1045
1356
normalized_filename = _inaccessible_normalized_filename
1359
def set_signal_handler(signum, handler, restart_syscall=True):
1360
"""A wrapper for signal.signal that also calls siginterrupt(signum, False)
1361
on platforms that support that.
1363
:param restart_syscall: if set, allow syscalls interrupted by a signal to
1364
automatically restart (by calling `signal.siginterrupt(signum,
1365
False)`). May be ignored if the feature is not available on this
1366
platform or Python version.
1369
siginterrupt = signal.siginterrupt
1370
except AttributeError:
1371
# siginterrupt doesn't exist on this platform, or for this version
1373
siginterrupt = lambda signum, flag: None
1375
def sig_handler(*args):
1376
# Python resets the siginterrupt flag when a signal is
1377
# received. <http://bugs.python.org/issue8354>
1378
# As a workaround for some cases, set it back the way we want it.
1379
siginterrupt(signum, False)
1380
# Now run the handler function passed to set_signal_handler.
1383
sig_handler = handler
1384
old_handler = signal.signal(signum, sig_handler)
1386
siginterrupt(signum, False)
1390
default_terminal_width = 80
1391
"""The default terminal width for ttys.
1393
This is defined so that higher levels can share a common fallback value when
1394
terminal_width() returns None.
1048
1398
def terminal_width():
1049
"""Return estimated terminal width."""
1050
if sys.platform == 'win32':
1051
return win32utils.get_console_size()[0]
1399
"""Return terminal width.
1401
None is returned if the width can't established precisely.
1404
- if BZR_COLUMNS is set, returns its value
1405
- if there is no controlling terminal, returns None
1406
- if COLUMNS is set, returns its value,
1408
From there, we need to query the OS to get the size of the controlling
1412
- get termios.TIOCGWINSZ
1413
- if an error occurs or a negative value is obtained, returns None
1417
- win32utils.get_console_size() decides,
1418
- returns None on error (provided default value)
1421
# If BZR_COLUMNS is set, take it, user is always right
1423
return int(os.environ['BZR_COLUMNS'])
1424
except (KeyError, ValueError):
1427
isatty = getattr(sys.stdout, 'isatty', None)
1428
if isatty is None or not isatty():
1429
# Don't guess, setting BZR_COLUMNS is the recommended way to override.
1432
# If COLUMNS is set, take it, the terminal knows better (even inside a
1433
# given terminal, the application can decide to set COLUMNS to a lower
1434
# value (splitted screen) or a bigger value (scroll bars))
1436
return int(os.environ['COLUMNS'])
1437
except (KeyError, ValueError):
1440
width, height = _terminal_size(None, None)
1442
# Consider invalid values as meaning no width
1448
def _win32_terminal_size(width, height):
1449
width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
1450
return width, height
1453
def _ioctl_terminal_size(width, height):
1054
1455
import struct, fcntl, termios
1055
1456
s = struct.pack('HHHH', 0, 0, 0, 0)
1056
1457
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1057
width = struct.unpack('HHHH', x)[1]
1458
height, width = struct.unpack('HHHH', x)[0:2]
1459
except (IOError, AttributeError):
1062
width = int(os.environ['COLUMNS'])
1461
return width, height
1463
_terminal_size = None
1464
"""Returns the terminal size as (width, height).
1466
:param width: Default value for width.
1467
:param height: Default value for height.
1469
This is defined specifically for each OS and query the size of the controlling
1470
terminal. If any error occurs, the provided default values should be returned.
1472
if sys.platform == 'win32':
1473
_terminal_size = _win32_terminal_size
1475
_terminal_size = _ioctl_terminal_size
1478
def _terminal_size_changed(signum, frame):
1479
"""Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
1480
width, height = _terminal_size(None, None)
1481
if width is not None:
1482
os.environ['COLUMNS'] = str(width)
1485
_registered_sigwinch = False
1487
def watch_sigwinch():
1488
"""Register for SIGWINCH, once and only once."""
1489
global _registered_sigwinch
1490
if not _registered_sigwinch:
1491
if sys.platform == 'win32':
1492
# Martin (gz) mentioned WINDOW_BUFFER_SIZE_RECORD from
1493
# ReadConsoleInput but I've no idea how to plug that in
1494
# the current design -- vila 20091216
1497
set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1498
_registered_sigwinch = True
1071
1501
def supports_executable():
1149
1579
def walkdirs(top, prefix=""):
1150
1580
"""Yield data about all the directories in a tree.
1152
1582
This yields all the data about the contents of a directory at a time.
1153
1583
After each directory has been yielded, if the caller has mutated the list
1154
1584
to exclude some directories, they are then not descended into.
1156
1586
The data yielded is of the form:
1157
1587
((directory-relpath, directory-path-from-top),
1158
1588
[(relpath, basename, kind, lstat, path-from-top), ...]),
1159
1589
- directory-relpath is the relative path of the directory being returned
1160
1590
with respect to top. prefix is prepended to this.
1161
- directory-path-from-root is the path including top for this directory.
1591
- directory-path-from-root is the path including top for this directory.
1162
1592
It is suitable for use with os functions.
1163
1593
- relpath is the relative path within the subtree being walked.
1164
1594
- basename is the basename of the path
1166
1596
present within the tree - but it may be recorded as versioned. See
1167
1597
versioned_kind.
1168
1598
- lstat is the stat data *if* the file was statted.
1169
- planned, not implemented:
1599
- planned, not implemented:
1170
1600
path_from_tree_root is the path from the root of the tree.
1172
:param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1602
:param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1173
1603
allows one to walk a subtree but get paths that are relative to a tree
1174
1604
rooted higher up.
1175
1605
:return: an iterator over the dirs.
1177
1607
#TODO there is a bit of a smell where the results of the directory-
1178
# summary in this, and the path from the root, may not agree
1608
# summary in this, and the path from the root, may not agree
1179
1609
# depending on top and prefix - i.e. ./foo and foo as a pair leads to
1180
1610
# potentially confusing output. We should make this more robust - but
1181
1611
# not at a speed cost. RBC 20060731
1265
1695
# for win98 anyway.
1267
1697
from bzrlib._walkdirs_win32 import Win32ReadDir
1269
_selected_dir_reader = UnicodeDirReader()
1271
1698
_selected_dir_reader = Win32ReadDir()
1272
elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1701
elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1273
1702
# ANSI_X3.4-1968 is a form of ASCII
1274
_selected_dir_reader = UnicodeDirReader()
1277
1704
from bzrlib._readdir_pyx import UTF8DirReader
1279
# No optimised code path
1280
_selected_dir_reader = UnicodeDirReader()
1282
1705
_selected_dir_reader = UTF8DirReader()
1706
except ImportError, e:
1707
failed_to_load_extension(e)
1710
if _selected_dir_reader is None:
1711
# Fallback to the python version
1712
_selected_dir_reader = UnicodeDirReader()
1283
1714
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1284
1715
# But we don't actually uses 1-3 in pending, so set them to None
1285
1716
pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1390
1821
real_handlers[kind](abspath, relpath)
1824
def copy_ownership(dst, src=None):
1825
"""Copy usr/grp ownership from src file/dir to dst file/dir.
1827
If src is None, the containing directory is used as source. If chown
1828
fails, the error is ignored and a warning is printed.
1830
chown = getattr(os, 'chown', None)
1835
src = os.path.dirname(dst)
1841
chown(dst, s.st_uid, s.st_gid)
1843
trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
1846
def mkdir_with_ownership(path, ownership_src=None):
1847
"""Create the directory 'path' with specified ownership.
1849
If ownership_src is given, copies (chown) usr/grp ownership
1850
from 'ownership_src' to 'path'. If ownership_src is None, use the
1851
containing dir ownership.
1854
copy_ownership(path, ownership_src)
1857
def open_with_ownership(filename, mode='r', bufsize=-1, ownership_src=None):
1858
"""Open the file 'filename' with the specified ownership.
1860
If ownership_src is specified, copy usr/grp ownership from ownership_src
1861
to filename. If ownership_src is None, copy ownership from containing
1863
Returns the opened file object.
1865
f = open(filename, mode, bufsize)
1866
copy_ownership(filename, ownership_src)
1393
1870
def path_prefix_key(path):
1394
1871
"""Generate a prefix-order path key for path.
1495
1972
return socket.gethostname().decode(get_user_encoding())
1498
def recv_all(socket, bytes):
1975
# We must not read/write any more than 64k at a time from/to a socket so we
1976
# don't risk "no buffer space available" errors on some platforms. Windows in
1977
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
1979
MAX_SOCKET_CHUNK = 64 * 1024
1981
def read_bytes_from_socket(sock, report_activity=None,
1982
max_read_size=MAX_SOCKET_CHUNK):
1983
"""Read up to max_read_size of bytes from sock and notify of progress.
1985
Translates "Connection reset by peer" into file-like EOF (return an
1986
empty string rather than raise an error), and repeats the recv if
1987
interrupted by a signal.
1991
bytes = sock.recv(max_read_size)
1992
except socket.error, e:
1994
if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
1995
# The connection was closed by the other side. Callers expect
1996
# an empty string to signal end-of-stream.
1998
elif eno == errno.EINTR:
1999
# Retry the interrupted recv.
2003
if report_activity is not None:
2004
report_activity(len(bytes), 'read')
2008
def recv_all(socket, count):
1499
2009
"""Receive an exact number of bytes.
1501
2011
Regular Socket.recv() may return less than the requested number of bytes,
1502
dependning on what's in the OS buffer. MSG_WAITALL is not available
2012
depending on what's in the OS buffer. MSG_WAITALL is not available
1503
2013
on all platforms, but this should work everywhere. This will return
1504
2014
less than the requested amount if the remote end closes.
1506
2016
This isn't optimized and is intended mostly for use in testing.
1509
while len(b) < bytes:
1510
new = socket.recv(bytes - len(b))
2019
while len(b) < count:
2020
new = read_bytes_from_socket(socket, None, count - len(b))
1517
def send_all(socket, bytes):
2027
def send_all(sock, bytes, report_activity=None):
1518
2028
"""Send all bytes on a socket.
2030
Breaks large blocks in smaller chunks to avoid buffering limitations on
2031
some platforms, and catches EINTR which may be thrown if the send is
2032
interrupted by a signal.
1520
Regular socket.sendall() can give socket error 10053 on Windows. This
1521
implementation sends no more than 64k at a time, which avoids this problem.
2034
This is preferred to socket.sendall(), because it avoids portability bugs
2035
and provides activity reporting.
2037
:param report_activity: Call this as bytes are read, see
2038
Transport._report_activity
1524
for pos in xrange(0, len(bytes), chunk_size):
1525
socket.sendall(bytes[pos:pos+chunk_size])
2041
byte_count = len(bytes)
2042
while sent_total < byte_count:
2044
sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2045
except socket.error, e:
2046
if e.args[0] != errno.EINTR:
2050
report_activity(sent, 'write')
1528
2053
def dereference_path(path):
2126
def until_no_eintr(f, *a, **kw):
2127
"""Run f(*a, **kw), retrying if an EINTR error occurs.
2129
WARNING: you must be certain that it is safe to retry the call repeatedly
2130
if EINTR does occur. This is typically only true for low-level operations
2131
like os.read. If in any doubt, don't use this.
2133
Keep in mind that this is not a complete solution to EINTR. There is
2134
probably code in the Python standard library and other dependencies that
2135
may encounter EINTR if a signal arrives (and there is signal handler for
2136
that signal). So this function can reduce the impact for IO that bzrlib
2137
directly controls, but it is not a complete solution.
2139
# Borrowed from Twisted's twisted.python.util.untilConcludes function.
2143
except (IOError, OSError), e:
2144
if e.errno == errno.EINTR:
2149
def re_compile_checked(re_string, flags=0, where=""):
2150
"""Return a compiled re, or raise a sensible error.
2152
This should only be used when compiling user-supplied REs.
2154
:param re_string: Text form of regular expression.
2155
:param flags: eg re.IGNORECASE
2156
:param where: Message explaining to the user the context where
2157
it occurred, eg 'log search filter'.
2159
# from https://bugs.launchpad.net/bzr/+bug/251352
2161
re_obj = re.compile(re_string, flags)
2166
where = ' in ' + where
2167
# despite the name 'error' is a type
2168
raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
2169
% (where, re_string, e))
2172
if sys.platform == "win32":
2175
return msvcrt.getch()
2180
fd = sys.stdin.fileno()
2181
settings = termios.tcgetattr(fd)
2184
ch = sys.stdin.read(1)
2186
termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2190
if sys.platform == 'linux2':
2191
def _local_concurrency():
2193
prefix = 'processor'
2194
for line in file('/proc/cpuinfo', 'rb'):
2195
if line.startswith(prefix):
2196
concurrency = int(line[line.find(':')+1:]) + 1
2198
elif sys.platform == 'darwin':
2199
def _local_concurrency():
2200
return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2201
stdout=subprocess.PIPE).communicate()[0]
2202
elif sys.platform[0:7] == 'freebsd':
2203
def _local_concurrency():
2204
return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2205
stdout=subprocess.PIPE).communicate()[0]
2206
elif sys.platform == 'sunos5':
2207
def _local_concurrency():
2208
return subprocess.Popen(['psrinfo', '-p',],
2209
stdout=subprocess.PIPE).communicate()[0]
2210
elif sys.platform == "win32":
2211
def _local_concurrency():
2212
# This appears to return the number of cores.
2213
return os.environ.get('NUMBER_OF_PROCESSORS')
2215
def _local_concurrency():
2220
_cached_local_concurrency = None
2222
def local_concurrency(use_cache=True):
2223
"""Return how many processes can be run concurrently.
2225
Rely on platform specific implementations and default to 1 (one) if
2226
anything goes wrong.
2228
global _cached_local_concurrency
2230
if _cached_local_concurrency is not None and use_cache:
2231
return _cached_local_concurrency
2233
concurrency = os.environ.get('BZR_CONCURRENCY', None)
2234
if concurrency is None:
2236
concurrency = _local_concurrency()
2237
except (OSError, IOError):
2240
concurrency = int(concurrency)
2241
except (TypeError, ValueError):
2244
_cached_concurrency = concurrency
2248
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
2249
"""A stream writer that doesn't decode str arguments."""
2251
def __init__(self, encode, stream, errors='strict'):
2252
codecs.StreamWriter.__init__(self, stream, errors)
2253
self.encode = encode
2255
def write(self, object):
2256
if type(object) is str:
2257
self.stream.write(object)
2259
data, _ = self.encode(object, self.errors)
2260
self.stream.write(data)
2262
if sys.platform == 'win32':
2263
def open_file(filename, mode='r', bufsize=-1):
2264
"""This function is used to override the ``open`` builtin.
2266
But it uses O_NOINHERIT flag so the file handle is not inherited by
2267
child processes. Deleting or renaming a closed file opened with this
2268
function is not blocking child processes.
2270
writing = 'w' in mode
2271
appending = 'a' in mode
2272
updating = '+' in mode
2273
binary = 'b' in mode
2276
# see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
2277
# for flags for each modes.
2287
flags |= os.O_WRONLY
2288
flags |= os.O_CREAT | os.O_TRUNC
2293
flags |= os.O_WRONLY
2294
flags |= os.O_CREAT | os.O_APPEND
2299
flags |= os.O_RDONLY
2301
return os.fdopen(os.open(filename, flags), mode, bufsize)
added
removed
bzrlib/osutils.py
