72
69
from bzrlib import symbol_versioning
75
# Cross platform wall-clock time functionality with decent resolution.
76
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
77
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
78
# synchronized with ``time.time()``, this is only meant to be used to find
79
# delta times by subtracting from another call to this function.
80
timer_func = time.time
81
if sys.platform == 'win32':
82
timer_func = time.clock
84
72
# On win32, O_BINARY is used to indicate the file should
85
73
# be opened in binary mode, rather than text mode.
86
74
# On other platforms, O_BINARY doesn't exist, because
87
75
# they always open in binary mode, so it is okay to
88
# OR with 0 on those platforms.
89
# O_NOINHERIT and O_TEXT exists only on win32 too.
76
# OR with 0 on those platforms
90
77
O_BINARY = getattr(os, 'O_BINARY', 0)
91
O_TEXT = getattr(os, 'O_TEXT', 0)
92
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
95
def get_unicode_argv():
97
user_encoding = get_user_encoding()
98
return [a.decode(user_encoding) for a in sys.argv[1:]]
99
except UnicodeDecodeError:
100
raise errors.BzrError(("Parameter '%r' is unsupported by the current "
104
80
def make_readonly(filename):
122
98
:param paths: A container (and hence not None) of paths.
123
99
:return: A set of paths sufficient to include everything in paths via
124
is_inside, drawn from the paths parameter.
100
is_inside_any, drawn from the paths parameter.
130
return path.split('/')
131
sorted_paths = sorted(list(paths), key=sort_key)
133
search_paths = [sorted_paths[0]]
134
for path in sorted_paths[1:]:
135
if not is_inside(search_paths[-1], path):
136
# This path is unique, add it
137
search_paths.append(path)
139
return set(search_paths)
105
other_paths = paths.difference([path])
106
if not is_inside_any(other_paths, path):
107
# this is a top level path, we must check it.
108
search_paths.add(path)
204
172
def fancy_rename(old, new, rename_func, unlink_func):
205
173
"""A fancy rename, when you don't have atomic rename.
207
175
:param old: The old path, to rename from
208
176
:param new: The new path, to rename to
209
177
:param rename_func: The potentially non-atomic rename function
210
: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
213
181
# sftp rename doesn't allow overwriting, so play tricks:
214
182
base = os.path.basename(new)
215
183
dirname = os.path.dirname(new)
216
# callers use different encodings for the paths so the following MUST
217
# respect that. We rely on python upcasting to unicode if new is unicode
218
# and keeping a str if not.
219
tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
220
os.getpid(), rand_chars(10))
184
tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
221
185
tmp_name = pathjoin(dirname, tmp_name)
223
187
# Rename the file out of the way, but keep track if it didn't exist
360
317
"""We expect to be able to atomically replace 'new' with old.
362
319
On win32, if new exists, it must be moved out of the way first,
366
323
fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
367
324
except OSError, e:
368
325
if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
369
# If we try to rename a non-existant file onto cwd, we get
370
# EPERM or EACCES instead of ENOENT, this will raise ENOENT
326
# If we try to rename a non-existant file onto cwd, we get
327
# EPERM or EACCES instead of ENOENT, this will raise ENOENT
371
328
# if the old path doesn't exist, sometimes we get EACCES
372
329
# On Linux, we seem to get EBUSY, on Mac we get EINVAL
735
658
date_str = time.strftime(date_fmt, tt)
736
659
return date_str + offset_str
739
# Cache of formatted offset strings
743
def format_date_with_offset_in_original_timezone(t, offset=0,
744
_cache=_offset_cache):
745
"""Return a formatted date string in the original timezone.
747
This routine may be faster then format_date.
749
:param t: Seconds since the epoch.
750
:param offset: Timezone offset in seconds east of utc.
754
tt = time.gmtime(t + offset)
755
date_fmt = _default_format_by_weekday_num[tt[6]]
756
date_str = time.strftime(date_fmt, tt)
757
offset_str = _cache.get(offset, None)
758
if offset_str is None:
759
offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
760
_cache[offset] = offset_str
761
return date_str + offset_str
764
661
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
765
662
show_offset=True):
766
663
"""Return an unicode date string formatted according to the current locale.
924
819
return pathjoin(*p)
927
def parent_directories(filename):
928
"""Return the list of parent directories, deepest first.
930
For example, parent_directories("a/b/c") -> ["a/b", "a"].
933
parts = splitpath(dirname(filename))
935
parents.append(joinpath(parts))
940
_extension_load_failures = []
943
def failed_to_load_extension(exception):
944
"""Handle failing to load a binary extension.
946
This should be called from the ImportError block guarding the attempt to
947
import the native extension. If this function returns, the pure-Python
948
implementation should be loaded instead::
951
>>> import bzrlib._fictional_extension_pyx
952
>>> except ImportError, e:
953
>>> bzrlib.osutils.failed_to_load_extension(e)
954
>>> import bzrlib._fictional_extension_py
956
# NB: This docstring is just an example, not a doctest, because doctest
957
# currently can't cope with the use of lazy imports in this namespace --
960
# This currently doesn't report the failure at the time it occurs, because
961
# they tend to happen very early in startup when we can't check config
962
# files etc, and also we want to report all failures but not spam the user
964
from bzrlib import trace
965
exception_str = str(exception)
966
if exception_str not in _extension_load_failures:
967
trace.mutter("failed to load compiled extension: %s" % exception_str)
968
_extension_load_failures.append(exception_str)
971
def report_extension_load_failures():
972
if not _extension_load_failures:
974
from bzrlib.config import GlobalConfig
975
if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
977
# the warnings framework should by default show this only once
978
from bzrlib.trace import warning
980
"bzr: warning: some compiled extensions could not be loaded; "
981
"see <https://answers.launchpad.net/bzr/+faq/703>")
982
# we no longer show the specific missing extensions here, because it makes
983
# the message too long and scary - see
984
# https://bugs.launchpad.net/bzr/+bug/430529
988
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
989
except ImportError, e:
990
failed_to_load_extension(e)
991
from bzrlib._chunks_to_lines_py import chunks_to_lines
994
822
def split_lines(s):
995
823
"""Split s into lines, but without removing the newline characters."""
996
# Trivially convert a fulltext into a 'chunked' representation, and let
997
# chunks_to_lines do the heavy lifting.
998
if isinstance(s, str):
999
# chunks_to_lines only supports 8-bit strings
1000
return chunks_to_lines([s])
1002
return _split_lines(s)
1005
def _split_lines(s):
1006
"""Split s into lines, but without removing the newline characters.
1008
This supports Unicode or plain string objects.
1010
824
lines = s.split('\n')
1011
825
result = [line + '\n' for line in lines[:-1]]
1031
845
shutil.copyfile(src, dest)
848
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
849
# Forgiveness than Permission (EAFP) because:
850
# - root can damage a solaris file system by using unlink,
851
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
852
# EACCES, OSX: EPERM) when invoked on a directory.
1034
853
def delete_any(path):
1035
"""Delete a file, symlink or directory.
1037
Will delete even if readonly.
1040
_delete_file_or_dir(path)
1041
except (OSError, IOError), e:
1042
if e.errno in (errno.EPERM, errno.EACCES):
1043
# make writable and try again
1046
except (OSError, IOError):
1048
_delete_file_or_dir(path)
1053
def _delete_file_or_dir(path):
1054
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
1055
# Forgiveness than Permission (EAFP) because:
1056
# - root can damage a solaris file system by using unlink,
1057
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
1058
# EACCES, OSX: EPERM) when invoked on a directory.
854
"""Delete a file or directory."""
1059
855
if isdir(path): # Takes care of symlinks
1148
if len(head) <= len(base) and head != base:
1149
raise errors.PathNotChild(rp, base)
929
while len(head) >= len(base):
1150
930
if head == base:
1152
head, tail = split(head)
932
head, tail = os.path.split(head)
936
raise errors.PathNotChild(rp, base)
1157
return pathjoin(*reversed(s))
1162
def _cicp_canonical_relpath(base, path):
1163
"""Return the canonical path relative to base.
1165
Like relpath, but on case-insensitive-case-preserving file-systems, this
1166
will return the relpath as stored on the file-system rather than in the
1167
case specified in the input string, for all existing portions of the path.
1169
This will cause O(N) behaviour if called for every path in a tree; if you
1170
have a number of paths to convert, you should use canonical_relpaths().
1172
# TODO: it should be possible to optimize this for Windows by using the
1173
# win32 API FindFiles function to look for the specified name - but using
1174
# os.listdir() still gives us the correct, platform agnostic semantics in
1177
rel = relpath(base, path)
1178
# '.' will have been turned into ''
1182
abs_base = abspath(base)
1184
_listdir = os.listdir
1186
# use an explicit iterator so we can easily consume the rest on early exit.
1187
bit_iter = iter(rel.split('/'))
1188
for bit in bit_iter:
1191
next_entries = _listdir(current)
1192
except OSError: # enoent, eperm, etc
1193
# We can't find this in the filesystem, so just append the
1195
current = pathjoin(current, bit, *list(bit_iter))
1197
for look in next_entries:
1198
if lbit == look.lower():
1199
current = pathjoin(current, look)
1202
# got to the end, nothing matched, so we just return the
1203
# non-existing bits as they were specified (the filename may be
1204
# the target of a move, for example).
1205
current = pathjoin(current, bit, *list(bit_iter))
1207
return current[len(abs_base):].lstrip('/')
1209
# XXX - TODO - we need better detection/integration of case-insensitive
1210
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
1211
# filesystems), for example, so could probably benefit from the same basic
1212
# support there. For now though, only Windows and OSX get that support, and
1213
# they get it for *all* file-systems!
1214
if sys.platform in ('win32', 'darwin'):
1215
canonical_relpath = _cicp_canonical_relpath
1217
canonical_relpath = relpath
1219
def canonical_relpaths(base, paths):
1220
"""Create an iterable to canonicalize a sequence of relative paths.
1222
The intent is for this implementation to use a cache, vastly speeding
1223
up multiple transformations in the same directory.
1225
# but for now, we haven't optimized...
1226
return [canonical_relpath(base, p) for p in paths]
1228
944
def safe_unicode(unicode_or_utf8_string):
1229
945
"""Coerce unicode_or_utf8_string into unicode.
1231
947
If it is unicode, it is returned.
1232
Otherwise it is decoded from utf-8. If decoding fails, the exception is
1233
wrapped in a BzrBadParameterNotUnicode exception.
948
Otherwise it is decoded from utf-8. If a decoding error
949
occurs, it is wrapped as a If the decoding fails, the exception is wrapped
950
as a BzrBadParameter exception.
1235
952
if isinstance(unicode_or_utf8_string, unicode):
1236
953
return unicode_or_utf8_string
1349
1066
normalized_filename = _inaccessible_normalized_filename
1352
default_terminal_width = 80
1353
"""The default terminal width for ttys.
1355
This is defined so that higher levels can share a common fallback value when
1356
terminal_width() returns None.
1360
1069
def terminal_width():
1361
"""Return terminal width.
1363
None is returned if the width can't established precisely.
1366
- if BZR_COLUMNS is set, returns its value
1367
- if there is no controlling terminal, returns None
1368
- if COLUMNS is set, returns its value,
1370
From there, we need to query the OS to get the size of the controlling
1374
- get termios.TIOCGWINSZ
1375
- if an error occurs or a negative value is obtained, returns None
1379
- win32utils.get_console_size() decides,
1380
- returns None on error (provided default value)
1383
# If BZR_COLUMNS is set, take it, user is always right
1385
return int(os.environ['BZR_COLUMNS'])
1386
except (KeyError, ValueError):
1389
isatty = getattr(sys.stdout, 'isatty', None)
1390
if isatty is None or not isatty():
1391
# Don't guess, setting BZR_COLUMNS is the recommended way to override.
1394
# If COLUMNS is set, take it, the terminal knows better (even inside a
1395
# given terminal, the application can decide to set COLUMNS to a lower
1396
# value (splitted screen) or a bigger value (scroll bars))
1398
return int(os.environ['COLUMNS'])
1399
except (KeyError, ValueError):
1402
width, height = _terminal_size(None, None)
1404
# Consider invalid values as meaning no width
1410
def _win32_terminal_size(width, height):
1411
width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
1412
return width, height
1415
def _ioctl_terminal_size(width, height):
1070
"""Return estimated terminal width."""
1071
if sys.platform == 'win32':
1072
return win32utils.get_console_size()[0]
1417
1075
import struct, fcntl, termios
1418
1076
s = struct.pack('HHHH', 0, 0, 0, 0)
1419
1077
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1420
height, width = struct.unpack('HHHH', x)[0:2]
1421
except (IOError, AttributeError):
1078
width = struct.unpack('HHHH', x)[1]
1423
return width, height
1425
_terminal_size = None
1426
"""Returns the terminal size as (width, height).
1428
:param width: Default value for width.
1429
:param height: Default value for height.
1431
This is defined specifically for each OS and query the size of the controlling
1432
terminal. If any error occurs, the provided default values should be returned.
1434
if sys.platform == 'win32':
1435
_terminal_size = _win32_terminal_size
1437
_terminal_size = _ioctl_terminal_size
1440
def _terminal_size_changed(signum, frame):
1441
"""Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
1442
width, height = _terminal_size(None, None)
1443
if width is not None:
1444
os.environ['COLUMNS'] = str(width)
1447
_registered_sigwinch = False
1449
def watch_sigwinch():
1450
"""Register for SIGWINCH, once and only once."""
1451
global _registered_sigwinch
1452
if not _registered_sigwinch:
1453
if sys.platform == 'win32':
1454
# Martin (gz) mentioned WINDOW_BUFFER_SIZE_RECORD from
1455
# ReadConsoleInput but I've no idea how to plug that in
1456
# the current design -- vila 20091216
1083
width = int(os.environ['COLUMNS'])
1459
signal.signal(signal.SIGWINCH, _terminal_size_changed)
1460
_registered_sigwinch = True
1463
1092
def supports_executable():
1541
1170
def walkdirs(top, prefix=""):
1542
1171
"""Yield data about all the directories in a tree.
1544
1173
This yields all the data about the contents of a directory at a time.
1545
1174
After each directory has been yielded, if the caller has mutated the list
1546
1175
to exclude some directories, they are then not descended into.
1548
1177
The data yielded is of the form:
1549
1178
((directory-relpath, directory-path-from-top),
1550
1179
[(relpath, basename, kind, lstat, path-from-top), ...]),
1551
1180
- directory-relpath is the relative path of the directory being returned
1552
1181
with respect to top. prefix is prepended to this.
1553
- directory-path-from-root is the path including top for this directory.
1182
- directory-path-from-root is the path including top for this directory.
1554
1183
It is suitable for use with os functions.
1555
1184
- relpath is the relative path within the subtree being walked.
1556
1185
- basename is the basename of the path
1558
1187
present within the tree - but it may be recorded as versioned. See
1559
1188
versioned_kind.
1560
1189
- lstat is the stat data *if* the file was statted.
1561
- planned, not implemented:
1190
- planned, not implemented:
1562
1191
path_from_tree_root is the path from the root of the tree.
1564
:param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1193
:param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1565
1194
allows one to walk a subtree but get paths that are relative to a tree
1566
1195
rooted higher up.
1567
1196
:return: an iterator over the dirs.
1569
1198
#TODO there is a bit of a smell where the results of the directory-
1570
# summary in this, and the path from the root, may not agree
1199
# summary in this, and the path from the root, may not agree
1571
1200
# depending on top and prefix - i.e. ./foo and foo as a pair leads to
1572
1201
# potentially confusing output. We should make this more robust - but
1573
1202
# not at a speed cost. RBC 20060731
1657
1286
# for win98 anyway.
1659
1288
from bzrlib._walkdirs_win32 import Win32ReadDir
1290
_selected_dir_reader = UnicodeDirReader()
1660
1292
_selected_dir_reader = Win32ReadDir()
1663
elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1293
elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1664
1294
# ANSI_X3.4-1968 is a form of ASCII
1295
_selected_dir_reader = UnicodeDirReader()
1666
1298
from bzrlib._readdir_pyx import UTF8DirReader
1300
# No optimised code path
1301
_selected_dir_reader = UnicodeDirReader()
1667
1303
_selected_dir_reader = UTF8DirReader()
1668
except ImportError, e:
1669
failed_to_load_extension(e)
1672
if _selected_dir_reader is None:
1673
# Fallback to the python version
1674
_selected_dir_reader = UnicodeDirReader()
1676
1304
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1677
1305
# But we don't actually uses 1-3 in pending, so set them to None
1678
1306
pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
1902
1530
while len(b) < bytes:
1903
new = until_no_eintr(socket.recv, bytes - len(b))
1531
new = socket.recv(bytes - len(b))
1910
def send_all(socket, bytes, report_activity=None):
1538
def send_all(socket, bytes):
1911
1539
"""Send all bytes on a socket.
1913
1541
Regular socket.sendall() can give socket error 10053 on Windows. This
1914
1542
implementation sends no more than 64k at a time, which avoids this problem.
1916
:param report_activity: Call this as bytes are read, see
1917
Transport._report_activity
1919
1544
chunk_size = 2**16
1920
1545
for pos in xrange(0, len(bytes), chunk_size):
1921
block = bytes[pos:pos+chunk_size]
1922
if report_activity is not None:
1923
report_activity(len(block), 'write')
1924
until_no_eintr(socket.sendall, block)
1546
socket.sendall(bytes[pos:pos+chunk_size])
1927
1549
def dereference_path(path):
2000
def until_no_eintr(f, *a, **kw):
2001
"""Run f(*a, **kw), retrying if an EINTR error occurs."""
2002
# Borrowed from Twisted's twisted.python.util.untilConcludes function.
2006
except (IOError, OSError), e:
2007
if e.errno == errno.EINTR:
2011
def re_compile_checked(re_string, flags=0, where=""):
2012
"""Return a compiled re, or raise a sensible error.
2014
This should only be used when compiling user-supplied REs.
2016
:param re_string: Text form of regular expression.
2017
:param flags: eg re.IGNORECASE
2018
:param where: Message explaining to the user the context where
2019
it occurred, eg 'log search filter'.
2021
# from https://bugs.launchpad.net/bzr/+bug/251352
2023
re_obj = re.compile(re_string, flags)
2028
where = ' in ' + where
2029
# despite the name 'error' is a type
2030
raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
2031
% (where, re_string, e))
2034
if sys.platform == "win32":
2037
return msvcrt.getch()
2042
fd = sys.stdin.fileno()
2043
settings = termios.tcgetattr(fd)
2046
ch = sys.stdin.read(1)
2048
termios.tcsetattr(fd, termios.TCSADRAIN, settings)
2052
if sys.platform == 'linux2':
2053
def _local_concurrency():
2055
prefix = 'processor'
2056
for line in file('/proc/cpuinfo', 'rb'):
2057
if line.startswith(prefix):
2058
concurrency = int(line[line.find(':')+1:]) + 1
2060
elif sys.platform == 'darwin':
2061
def _local_concurrency():
2062
return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
2063
stdout=subprocess.PIPE).communicate()[0]
2064
elif sys.platform[0:7] == 'freebsd':
2065
def _local_concurrency():
2066
return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
2067
stdout=subprocess.PIPE).communicate()[0]
2068
elif sys.platform == 'sunos5':
2069
def _local_concurrency():
2070
return subprocess.Popen(['psrinfo', '-p',],
2071
stdout=subprocess.PIPE).communicate()[0]
2072
elif sys.platform == "win32":
2073
def _local_concurrency():
2074
# This appears to return the number of cores.
2075
return os.environ.get('NUMBER_OF_PROCESSORS')
2077
def _local_concurrency():
2082
_cached_local_concurrency = None
2084
def local_concurrency(use_cache=True):
2085
"""Return how many processes can be run concurrently.
2087
Rely on platform specific implementations and default to 1 (one) if
2088
anything goes wrong.
2090
global _cached_local_concurrency
2092
if _cached_local_concurrency is not None and use_cache:
2093
return _cached_local_concurrency
2095
concurrency = os.environ.get('BZR_CONCURRENCY', None)
2096
if concurrency is None:
2098
concurrency = _local_concurrency()
2099
except (OSError, IOError):
2102
concurrency = int(concurrency)
2103
except (TypeError, ValueError):
2106
_cached_concurrency = concurrency
2110
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
2111
"""A stream writer that doesn't decode str arguments."""
2113
def __init__(self, encode, stream, errors='strict'):
2114
codecs.StreamWriter.__init__(self, stream, errors)
2115
self.encode = encode
2117
def write(self, object):
2118
if type(object) is str:
2119
self.stream.write(object)
2121
data, _ = self.encode(object, self.errors)
2122
self.stream.write(data)
2124
if sys.platform == 'win32':
2125
def open_file(filename, mode='r', bufsize=-1):
2126
"""This function is used to override the ``open`` builtin.
2128
But it uses O_NOINHERIT flag so the file handle is not inherited by
2129
child processes. Deleting or renaming a closed file opened with this
2130
function is not blocking child processes.
2132
writing = 'w' in mode
2133
appending = 'a' in mode
2134
updating = '+' in mode
2135
binary = 'b' in mode
2138
# see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
2139
# for flags for each modes.
2149
flags |= os.O_WRONLY
2150
flags |= os.O_CREAT | os.O_TRUNC
2155
flags |= os.O_WRONLY
2156
flags |= os.O_CREAT | os.O_APPEND
2161
flags |= os.O_RDONLY
2163
return os.fdopen(os.open(filename, flags), mode, bufsize)
added
removed
bzrlib/osutils.py
