77
69
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
89
72
# On win32, O_BINARY is used to indicate the file should
90
73
# be opened in binary mode, rather than text mode.
91
74
# On other platforms, O_BINARY doesn't exist, because
92
75
# they always open in binary mode, so it is okay to
93
# OR with 0 on those platforms.
94
# O_NOINHERIT and O_TEXT exists only on win32 too.
76
# OR with 0 on those platforms
95
77
O_BINARY = getattr(os, 'O_BINARY', 0)
96
O_TEXT = getattr(os, 'O_TEXT', 0)
97
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
100
80
def get_unicode_argv():
212
190
:param old: The old path, to rename from
213
191
:param new: The new path, to rename to
214
192
:param rename_func: The potentially non-atomic rename function
215
:param unlink_func: A way to delete the target file if the full rename
193
:param unlink_func: A way to delete the target file if the full rename succeeds
218
196
# sftp rename doesn't allow overwriting, so play tricks:
219
197
base = os.path.basename(new)
220
198
dirname = os.path.dirname(new)
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))
199
tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
226
200
tmp_name = pathjoin(dirname, tmp_name)
228
202
# Rename the file out of the way, but keep track if it didn't exist
758
705
date_str = time.strftime(date_fmt, tt)
759
706
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
787
708
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
788
709
show_offset=True):
789
710
"""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
1011
884
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1012
except ImportError, e:
1013
failed_to_load_extension(e)
1014
886
from bzrlib._chunks_to_lines_py import chunks_to_lines
1054
926
shutil.copyfile(src, dest)
929
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
930
# Forgiveness than Permission (EAFP) because:
931
# - root can damage a solaris file system by using unlink,
932
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
933
# EACCES, OSX: EPERM) when invoked on a directory.
1057
934
def delete_any(path):
1058
"""Delete a file, symlink or directory.
1060
Will delete even if readonly.
1063
_delete_file_or_dir(path)
1064
except (OSError, IOError), e:
1065
if e.errno in (errno.EPERM, errno.EACCES):
1066
# make writable and try again
1069
except (OSError, IOError):
1071
_delete_file_or_dir(path)
1076
def _delete_file_or_dir(path):
1077
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
1078
# Forgiveness than Permission (EAFP) because:
1079
# - root can damage a solaris file system by using unlink,
1080
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1081
# EACCES, OSX: EPERM) when invoked on a directory.
935
"""Delete a file or directory."""
1082
936
if isdir(path): # Takes care of symlinks
1375
1219
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.
1422
1222
def terminal_width():
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):
1223
"""Return estimated terminal width."""
1224
if sys.platform == 'win32':
1225
return win32utils.get_console_size()[0]
1479
1228
import struct, fcntl, termios
1480
1229
s = struct.pack('HHHH', 0, 0, 0, 0)
1481
1230
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1482
height, width = struct.unpack('HHHH', x)[0:2]
1483
except (IOError, AttributeError):
1231
width = struct.unpack('HHHH', x)[1]
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:
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
1236
width = int(os.environ['COLUMNS'])
1524
_registered_sigwinch = True
1527
1245
def supports_executable():
1974
1669
return socket.gethostname().decode(get_user_encoding())
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):
1672
def recv_all(socket, bytes):
2011
1673
"""Receive an exact number of bytes.
2013
1675
Regular Socket.recv() may return less than the requested number of bytes,
2014
depending on what's in the OS buffer. MSG_WAITALL is not available
1676
dependning on what's in the OS buffer. MSG_WAITALL is not available
2015
1677
on all platforms, but this should work everywhere. This will return
2016
1678
less than the requested amount if the remote end closes.
2018
1680
This isn't optimized and is intended mostly for use in testing.
2021
while len(b) < count:
2022
new = read_bytes_from_socket(socket, None, count - len(b))
1683
while len(b) < bytes:
1684
new = until_no_eintr(socket.recv, bytes - len(b))
2029
def send_all(sock, bytes, report_activity=None):
1691
def send_all(socket, bytes, report_activity=None):
2030
1692
"""Send all bytes on a socket.
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.
1694
Regular socket.sendall() can give socket error 10053 on Windows. This
1695
implementation sends no more than 64k at a time, which avoids this problem.
2039
1697
:param report_activity: Call this as bytes are read, see
2040
1698
Transport._report_activity
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')
1701
for pos in xrange(0, len(bytes), chunk_size):
1702
block = bytes[pos:pos+chunk_size]
1703
if report_activity is not None:
1704
report_activity(len(block), 'write')
1705
until_no_eintr(socket.sendall, block)
2055
1708
def dereference_path(path):
2188
1827
termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2192
if sys.platform == 'linux2':
2193
def _local_concurrency():
2195
prefix = 'processor'
2196
for line in file('/proc/cpuinfo', 'rb'):
2197
if line.startswith(prefix):
2198
concurrency = int(line[line.find(':')+1:]) + 1
2200
elif sys.platform == 'darwin':
2201
def _local_concurrency():
2202
return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2203
stdout=subprocess.PIPE).communicate()[0]
2204
elif sys.platform[0:7] == 'freebsd':
2205
def _local_concurrency():
2206
return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2207
stdout=subprocess.PIPE).communicate()[0]
2208
elif sys.platform == 'sunos5':
2209
def _local_concurrency():
2210
return subprocess.Popen(['psrinfo', '-p',],
2211
stdout=subprocess.PIPE).communicate()[0]
2212
elif sys.platform == "win32":
2213
def _local_concurrency():
2214
# This appears to return the number of cores.
2215
return os.environ.get('NUMBER_OF_PROCESSORS')
2217
def _local_concurrency():
2222
_cached_local_concurrency = None
2224
def local_concurrency(use_cache=True):
2225
"""Return how many processes can be run concurrently.
2227
Rely on platform specific implementations and default to 1 (one) if
2228
anything goes wrong.
2230
global _cached_local_concurrency
2232
if _cached_local_concurrency is not None and use_cache:
2233
return _cached_local_concurrency
2235
concurrency = os.environ.get('BZR_CONCURRENCY', None)
2236
if concurrency is None:
2238
concurrency = _local_concurrency()
2239
except (OSError, IOError):
2242
concurrency = int(concurrency)
2243
except (TypeError, ValueError):
2246
_cached_concurrency = 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
