13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20
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)
25
25
from bzrlib.lazy_import import lazy_import
26
26
lazy_import(globals(), """
27
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
758
667
date_str = time.strftime(date_fmt, tt)
759
668
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
670
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
788
671
show_offset=True):
789
672
"""Return an unicode date string formatted according to the current locale.
947
829
return pathjoin(*p)
950
def parent_directories(filename):
951
"""Return the list of parent directories, deepest first.
953
For example, parent_directories("a/b/c") -> ["a/b", "a"].
956
parts = splitpath(dirname(filename))
958
parents.append(joinpath(parts))
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
833
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1012
except ImportError, e:
1013
failed_to_load_extension(e)
1014
835
from bzrlib._chunks_to_lines_py import chunks_to_lines
1054
875
shutil.copyfile(src, dest)
878
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
879
# Forgiveness than Permission (EAFP) because:
880
# - root can damage a solaris file system by using unlink,
881
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
882
# EACCES, OSX: EPERM) when invoked on a directory.
1057
883
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.
884
"""Delete a file or directory."""
1082
885
if isdir(path): # Takes care of symlinks
1230
1009
# the target of a move, for example).
1231
1010
current = pathjoin(current, bit, *list(bit_iter))
1233
return current[len(abs_base):].lstrip('/')
1012
return current[len(abs_base)+1:]
1235
1014
# XXX - TODO - we need better detection/integration of case-insensitive
1236
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1237
# filesystems), for example, so could probably benefit from the same basic
1238
# support there. For now though, only Windows and OSX get that support, and
1239
# they get it for *all* file-systems!
1240
if sys.platform in ('win32', 'darwin'):
1015
# file-systems; Linux often sees FAT32 devices, for example, so could
1016
# probably benefit from the same basic support there. For now though, only
1017
# Windows gets that support, and it gets it for *all* file-systems!
1018
if sys.platform == "win32":
1241
1019
canonical_relpath = _cicp_canonical_relpath
1243
1021
canonical_relpath = relpath
1375
1154
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
1157
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):
1158
"""Return estimated terminal width."""
1159
if sys.platform == 'win32':
1160
return win32utils.get_console_size()[0]
1479
1163
import struct, fcntl, termios
1480
1164
s = struct.pack('HHHH', 0, 0, 0, 0)
1481
1165
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1482
height, width = struct.unpack('HHHH', x)[0:2]
1483
except (IOError, AttributeError):
1166
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
1171
width = int(os.environ['COLUMNS'])
1524
_registered_sigwinch = True
1527
1180
def supports_executable():
1721
1374
# for win98 anyway.
1723
1376
from bzrlib._walkdirs_win32 import Win32ReadDir
1378
_selected_dir_reader = UnicodeDirReader()
1724
1380
_selected_dir_reader = Win32ReadDir()
1727
elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1381
elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1728
1382
# ANSI_X3.4-1968 is a form of ASCII
1383
_selected_dir_reader = UnicodeDirReader()
1730
1386
from bzrlib._readdir_pyx import UTF8DirReader
1388
# No optimised code path
1389
_selected_dir_reader = UnicodeDirReader()
1731
1391
_selected_dir_reader = UTF8DirReader()
1732
except ImportError, e:
1733
failed_to_load_extension(e)
1736
if _selected_dir_reader is None:
1737
# Fallback to the python version
1738
_selected_dir_reader = UnicodeDirReader()
1740
1392
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1741
1393
# But we don't actually uses 1-3 in pending, so set them to None
1742
1394
pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1974
1604
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):
1607
def recv_all(socket, bytes):
2011
1608
"""Receive an exact number of bytes.
2013
1610
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
1611
dependning on what's in the OS buffer. MSG_WAITALL is not available
2015
1612
on all platforms, but this should work everywhere. This will return
2016
1613
less than the requested amount if the remote end closes.
2018
1615
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))
1618
while len(b) < bytes:
1619
new = until_no_eintr(socket.recv, bytes - len(b))
2029
def send_all(sock, bytes, report_activity=None):
1626
def send_all(socket, bytes):
2030
1627
"""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.
2039
:param report_activity: Call this as bytes are read, see
2040
Transport._report_activity
1629
Regular socket.sendall() can give socket error 10053 on Windows. This
1630
implementation sends no more than 64k at a time, which avoids this problem.
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')
1633
for pos in xrange(0, len(bytes), chunk_size):
1634
until_no_eintr(socket.sendall, bytes[pos:pos+chunk_size])
2055
1637
def dereference_path(path):
2188
1734
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
