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
21
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
26
25
from bzrlib.lazy_import import lazy_import
27
26
lazy_import(globals(), """
28
28
from datetime import datetime
30
30
from ntpath import (abspath as _nt_abspath,
32
32
normpath as _nt_normpath,
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
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 "
109
80
def make_readonly(filename):
212
175
:param old: The old path, to rename from
213
176
:param new: The new path, to rename to
214
177
:param rename_func: The potentially non-atomic rename function
215
:param unlink_func: A way to delete the target file if the full rename
178
:param unlink_func: A way to delete the target file if the full rename succeeds
218
181
# sftp rename doesn't allow overwriting, so play tricks:
219
182
base = os.path.basename(new)
220
183
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))
184
tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
226
185
tmp_name = pathjoin(dirname, tmp_name)
228
187
# Rename the file out of the way, but keep track if it didn't exist
740
685
date_str = time.strftime(date_fmt, tt)
741
686
return date_str + offset_str
744
# Cache of formatted offset strings
748
def format_date_with_offset_in_original_timezone(t, offset=0,
749
_cache=_offset_cache):
750
"""Return a formatted date string in the original timezone.
752
This routine may be faster then format_date.
754
:param t: Seconds since the epoch.
755
:param offset: Timezone offset in seconds east of utc.
759
tt = time.gmtime(t + offset)
760
date_fmt = _default_format_by_weekday_num[tt[6]]
761
date_str = time.strftime(date_fmt, tt)
762
offset_str = _cache.get(offset, None)
763
if offset_str is None:
764
offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
765
_cache[offset] = offset_str
766
return date_str + offset_str
769
688
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
770
689
show_offset=True):
771
690
"""Return an unicode date string formatted according to the current locale.
929
847
return pathjoin(*p)
932
def parent_directories(filename):
933
"""Return the list of parent directories, deepest first.
935
For example, parent_directories("a/b/c") -> ["a/b", "a"].
938
parts = splitpath(dirname(filename))
940
parents.append(joinpath(parts))
945
_extension_load_failures = []
948
def failed_to_load_extension(exception):
949
"""Handle failing to load a binary extension.
951
This should be called from the ImportError block guarding the attempt to
952
import the native extension. If this function returns, the pure-Python
953
implementation should be loaded instead::
956
>>> import bzrlib._fictional_extension_pyx
957
>>> except ImportError, e:
958
>>> bzrlib.osutils.failed_to_load_extension(e)
959
>>> import bzrlib._fictional_extension_py
961
# NB: This docstring is just an example, not a doctest, because doctest
962
# currently can't cope with the use of lazy imports in this namespace --
965
# This currently doesn't report the failure at the time it occurs, because
966
# they tend to happen very early in startup when we can't check config
967
# files etc, and also we want to report all failures but not spam the user
969
from bzrlib import trace
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
993
851
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
994
except ImportError, e:
995
failed_to_load_extension(e)
996
853
from bzrlib._chunks_to_lines_py import chunks_to_lines
1036
893
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.
1039
901
def delete_any(path):
1040
"""Delete a file, symlink or directory.
1042
Will delete even if readonly.
1045
_delete_file_or_dir(path)
1046
except (OSError, IOError), e:
1047
if e.errno in (errno.EPERM, errno.EACCES):
1048
# make writable and try again
1051
except (OSError, IOError):
1053
_delete_file_or_dir(path)
1058
def _delete_file_or_dir(path):
1059
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
1060
# Forgiveness than Permission (EAFP) because:
1061
# - root can damage a solaris file system by using unlink,
1062
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1063
# EACCES, OSX: EPERM) when invoked on a directory.
902
"""Delete a file or directory."""
1064
903
if isdir(path): # Takes care of symlinks
1212
1027
# the target of a move, for example).
1213
1028
current = pathjoin(current, bit, *list(bit_iter))
1215
return current[len(abs_base):].lstrip('/')
1030
return current[len(abs_base)+1:]
1217
1032
# XXX - TODO - we need better detection/integration of case-insensitive
1218
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1219
# filesystems), for example, so could probably benefit from the same basic
1220
# support there. For now though, only Windows and OSX get that support, and
1221
# they get it for *all* file-systems!
1222
if sys.platform in ('win32', 'darwin'):
1033
# file-systems; Linux often sees FAT32 devices, for example, so could
1034
# probably benefit from the same basic support there. For now though, only
1035
# Windows gets that support, and it gets it for *all* file-systems!
1036
if sys.platform == "win32":
1223
1037
canonical_relpath = _cicp_canonical_relpath
1225
1039
canonical_relpath = relpath
1357
1172
normalized_filename = _inaccessible_normalized_filename
1360
def set_signal_handler(signum, handler, restart_syscall=True):
1361
"""A wrapper for signal.signal that also calls siginterrupt(signum, False)
1362
on platforms that support that.
1364
:param restart_syscall: if set, allow syscalls interrupted by a signal to
1365
automatically restart (by calling `signal.siginterrupt(signum,
1366
False)`). May be ignored if the feature is not available on this
1367
platform or Python version.
1371
siginterrupt = signal.siginterrupt
1373
# This python implementation doesn't provide signal support, hence no
1376
except AttributeError:
1377
# siginterrupt doesn't exist on this platform, or for this version
1379
siginterrupt = lambda signum, flag: None
1381
def sig_handler(*args):
1382
# Python resets the siginterrupt flag when a signal is
1383
# received. <http://bugs.python.org/issue8354>
1384
# As a workaround for some cases, set it back the way we want it.
1385
siginterrupt(signum, False)
1386
# Now run the handler function passed to set_signal_handler.
1389
sig_handler = handler
1390
old_handler = signal.signal(signum, sig_handler)
1392
siginterrupt(signum, False)
1396
default_terminal_width = 80
1397
"""The default terminal width for ttys.
1399
This is defined so that higher levels can share a common fallback value when
1400
terminal_width() returns None.
1404
1175
def terminal_width():
1405
"""Return terminal width.
1407
None is returned if the width can't established precisely.
1410
- if BZR_COLUMNS is set, returns its value
1411
- if there is no controlling terminal, returns None
1412
- if COLUMNS is set, returns its value,
1414
From there, we need to query the OS to get the size of the controlling
1418
- get termios.TIOCGWINSZ
1419
- if an error occurs or a negative value is obtained, returns None
1423
- win32utils.get_console_size() decides,
1424
- returns None on error (provided default value)
1427
# If BZR_COLUMNS is set, take it, user is always right
1429
return int(os.environ['BZR_COLUMNS'])
1430
except (KeyError, ValueError):
1433
isatty = getattr(sys.stdout, 'isatty', None)
1434
if isatty is None or not isatty():
1435
# Don't guess, setting BZR_COLUMNS is the recommended way to override.
1438
# If COLUMNS is set, take it, the terminal knows better (even inside a
1439
# given terminal, the application can decide to set COLUMNS to a lower
1440
# value (splitted screen) or a bigger value (scroll bars))
1442
return int(os.environ['COLUMNS'])
1443
except (KeyError, ValueError):
1446
width, height = _terminal_size(None, None)
1448
# Consider invalid values as meaning no width
1454
def _win32_terminal_size(width, height):
1455
width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
1456
return width, height
1459
def _ioctl_terminal_size(width, height):
1176
"""Return estimated terminal width."""
1177
if sys.platform == 'win32':
1178
return win32utils.get_console_size()[0]
1461
1181
import struct, fcntl, termios
1462
1182
s = struct.pack('HHHH', 0, 0, 0, 0)
1463
1183
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1464
height, width = struct.unpack('HHHH', x)[0:2]
1465
except (IOError, AttributeError):
1184
width = struct.unpack('HHHH', x)[1]
1467
return width, height
1469
_terminal_size = None
1470
"""Returns the terminal size as (width, height).
1472
:param width: Default value for width.
1473
:param height: Default value for height.
1475
This is defined specifically for each OS and query the size of the controlling
1476
terminal. If any error occurs, the provided default values should be returned.
1478
if sys.platform == 'win32':
1479
_terminal_size = _win32_terminal_size
1481
_terminal_size = _ioctl_terminal_size
1484
def _terminal_size_changed(signum, frame):
1485
"""Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
1486
width, height = _terminal_size(None, None)
1487
if width is not None:
1488
os.environ['COLUMNS'] = str(width)
1491
_registered_sigwinch = False
1492
def watch_sigwinch():
1493
"""Register for SIGWINCH, once and only once.
1495
Do nothing if the signal module is not available.
1497
global _registered_sigwinch
1498
if not _registered_sigwinch:
1501
if getattr(signal, "SIGWINCH", None) is not None:
1502
set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
1504
# python doesn't provide signal support, nothing we can do about it
1189
width = int(os.environ['COLUMNS'])
1506
_registered_sigwinch = True
1509
1198
def supports_executable():
1703
1392
# for win98 anyway.
1705
1394
from bzrlib._walkdirs_win32 import Win32ReadDir
1396
_selected_dir_reader = UnicodeDirReader()
1706
1398
_selected_dir_reader = Win32ReadDir()
1709
elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1399
elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1710
1400
# ANSI_X3.4-1968 is a form of ASCII
1401
_selected_dir_reader = UnicodeDirReader()
1712
1404
from bzrlib._readdir_pyx import UTF8DirReader
1406
# No optimised code path
1407
_selected_dir_reader = UnicodeDirReader()
1713
1409
_selected_dir_reader = UTF8DirReader()
1714
except ImportError, e:
1715
failed_to_load_extension(e)
1718
if _selected_dir_reader is None:
1719
# Fallback to the python version
1720
_selected_dir_reader = UnicodeDirReader()
1722
1410
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1723
1411
# But we don't actually uses 1-3 in pending, so set them to None
1724
1412
pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1956
1622
return socket.gethostname().decode(get_user_encoding())
1959
# We must not read/write any more than 64k at a time from/to a socket so we
1960
# don't risk "no buffer space available" errors on some platforms. Windows in
1961
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
1963
MAX_SOCKET_CHUNK = 64 * 1024
1965
def read_bytes_from_socket(sock, report_activity=None,
1966
max_read_size=MAX_SOCKET_CHUNK):
1967
"""Read up to max_read_size of bytes from sock and notify of progress.
1969
Translates "Connection reset by peer" into file-like EOF (return an
1970
empty string rather than raise an error), and repeats the recv if
1971
interrupted by a signal.
1975
bytes = sock.recv(max_read_size)
1976
except socket.error, e:
1978
if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
1979
# The connection was closed by the other side. Callers expect
1980
# an empty string to signal end-of-stream.
1982
elif eno == errno.EINTR:
1983
# Retry the interrupted recv.
1987
if report_activity is not None:
1988
report_activity(len(bytes), 'read')
1992
def recv_all(socket, count):
1625
def recv_all(socket, bytes):
1993
1626
"""Receive an exact number of bytes.
1995
1628
Regular Socket.recv() may return less than the requested number of bytes,
1996
depending on what's in the OS buffer. MSG_WAITALL is not available
1629
dependning on what's in the OS buffer. MSG_WAITALL is not available
1997
1630
on all platforms, but this should work everywhere. This will return
1998
1631
less than the requested amount if the remote end closes.
2000
1633
This isn't optimized and is intended mostly for use in testing.
2003
while len(b) < count:
2004
new = read_bytes_from_socket(socket, None, count - len(b))
1636
while len(b) < bytes:
1637
new = until_no_eintr(socket.recv, bytes - len(b))
2011
def send_all(sock, bytes, report_activity=None):
1644
def send_all(socket, bytes, report_activity=None):
2012
1645
"""Send all bytes on a socket.
2014
Breaks large blocks in smaller chunks to avoid buffering limitations on
2015
some platforms, and catches EINTR which may be thrown if the send is
2016
interrupted by a signal.
2018
This is preferred to socket.sendall(), because it avoids portability bugs
2019
and provides activity reporting.
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.
2021
1650
:param report_activity: Call this as bytes are read, see
2022
1651
Transport._report_activity
2025
byte_count = len(bytes)
2026
while sent_total < byte_count:
2028
sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
2029
except socket.error, e:
2030
if e.args[0] != errno.EINTR:
2034
report_activity(sent, 'write')
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)
2037
1661
def dereference_path(path):
2170
1780
termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2174
if sys.platform == 'linux2':
2175
def _local_concurrency():
2177
prefix = 'processor'
2178
for line in file('/proc/cpuinfo', 'rb'):
2179
if line.startswith(prefix):
2180
concurrency = int(line[line.find(':')+1:]) + 1
2182
elif sys.platform == 'darwin':
2183
def _local_concurrency():
2184
return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2185
stdout=subprocess.PIPE).communicate()[0]
2186
elif sys.platform[0:7] == 'freebsd':
2187
def _local_concurrency():
2188
return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2189
stdout=subprocess.PIPE).communicate()[0]
2190
elif sys.platform == 'sunos5':
2191
def _local_concurrency():
2192
return subprocess.Popen(['psrinfo', '-p',],
2193
stdout=subprocess.PIPE).communicate()[0]
2194
elif sys.platform == "win32":
2195
def _local_concurrency():
2196
# This appears to return the number of cores.
2197
return os.environ.get('NUMBER_OF_PROCESSORS')
2199
def _local_concurrency():
2204
_cached_local_concurrency = None
2206
def local_concurrency(use_cache=True):
2207
"""Return how many processes can be run concurrently.
2209
Rely on platform specific implementations and default to 1 (one) if
2210
anything goes wrong.
2212
global _cached_local_concurrency
2214
if _cached_local_concurrency is not None and use_cache:
2215
return _cached_local_concurrency
2217
concurrency = os.environ.get('BZR_CONCURRENCY', None)
2218
if concurrency is None:
2220
concurrency = _local_concurrency()
2221
except (OSError, IOError):
2224
concurrency = int(concurrency)
2225
except (TypeError, ValueError):
2228
_cached_concurrency = concurrency
2232
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
2233
"""A stream writer that doesn't decode str arguments."""
2235
def __init__(self, encode, stream, errors='strict'):
2236
codecs.StreamWriter.__init__(self, stream, errors)
2237
self.encode = encode
2239
def write(self, object):
2240
if type(object) is str:
2241
self.stream.write(object)
2243
data, _ = self.encode(object, self.errors)
2244
self.stream.write(data)
2246
if sys.platform == 'win32':
2247
def open_file(filename, mode='r', bufsize=-1):
2248
"""This function is used to override the ``open`` builtin.
2250
But it uses O_NOINHERIT flag so the file handle is not inherited by
2251
child processes. Deleting or renaming a closed file opened with this
2252
function is not blocking child processes.
2254
writing = 'w' in mode
2255
appending = 'a' in mode
2256
updating = '+' in mode
2257
binary = 'b' in mode
2260
# see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
2261
# for flags for each modes.
2271
flags |= os.O_WRONLY
2272
flags |= os.O_CREAT | os.O_TRUNC
2277
flags |= os.O_WRONLY
2278
flags |= os.O_CREAT | os.O_APPEND
2283
flags |= os.O_RDONLY
2285
return os.fdopen(os.open(filename, flags), mode, bufsize)
2290
def getuser_unicode():
2291
"""Return the username as unicode.
2294
user_encoding = get_user_encoding()
2295
username = getpass.getuser().decode(user_encoding)
2296
except UnicodeDecodeError:
2297
raise errors.BzrError("Can't decode username as %s." % \
added
removed
bzrlib/osutils.py
