88
_directory_kind = 'directory'
91
stat.S_IFDIR:_directory_kind,
92
stat.S_IFCHR:'chardev',
96
stat.S_IFLNK:'symlink',
97
stat.S_IFSOCK:'socket',
101
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
102
"""Generate a file kind from a stat mode. This is used in walkdirs.
104
Its performance is critical: Do not mutate without careful benchmarking.
107
return _formats[stat_mode & 0170000]
112
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
114
return _mapper(_lstat(f).st_mode)
116
if getattr(e, 'errno', None) == errno.ENOENT:
117
raise bzrlib.errors.NoSuchFile(f)
70
mode = os.lstat(f)[ST_MODE]
121
89
def kind_marker(kind):
122
90
if kind == 'file':
124
elif kind == _directory_kind:
92
elif kind == 'directory':
126
94
elif kind == 'symlink':
129
97
raise BzrError('invalid file kind %r' % kind)
131
lexists = getattr(os.path, 'lexists', None)
135
if hasattr(os, 'lstat'):
141
if e.errno == errno.ENOENT:
144
raise BzrError("lstat/stat of (%r): %r" % (f, e))
147
def fancy_rename(old, new, rename_func, unlink_func):
148
"""A fancy rename, when you don't have atomic rename.
150
:param old: The old path, to rename from
151
:param new: The new path, to rename to
152
:param rename_func: The potentially non-atomic rename function
153
:param unlink_func: A way to delete the target file if the full rename succeeds
156
# sftp rename doesn't allow overwriting, so play tricks:
158
base = os.path.basename(new)
159
dirname = os.path.dirname(new)
160
tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
161
tmp_name = pathjoin(dirname, tmp_name)
163
# Rename the file out of the way, but keep track if it didn't exist
164
# We don't want to grab just any exception
165
# something like EACCES should prevent us from continuing
166
# The downside is that the rename_func has to throw an exception
167
# with an errno = ENOENT, or NoSuchFile
170
rename_func(new, tmp_name)
171
except (NoSuchFile,), e:
174
# RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
175
# function raises an IOError with errno == None when a rename fails.
176
# This then gets caught here.
177
if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
180
if (not hasattr(e, 'errno')
181
or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
188
# This may throw an exception, in which case success will
190
rename_func(old, new)
194
# If the file used to exist, rename it back into place
195
# otherwise just delete it from the tmp location
197
unlink_func(tmp_name)
199
rename_func(tmp_name, new)
202
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
203
# choke on a Unicode string containing a relative path if
204
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
206
_fs_enc = sys.getfilesystemencoding()
207
def _posix_abspath(path):
208
# jam 20060426 rather than encoding to fsencoding
209
# copy posixpath.abspath, but use os.getcwdu instead
210
if not posixpath.isabs(path):
211
path = posixpath.join(getcwd(), path)
212
return posixpath.normpath(path)
215
def _posix_realpath(path):
216
return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
219
def _win32_fixdrive(path):
220
"""Force drive letters to be consistent.
222
win32 is inconsistent whether it returns lower or upper case
223
and even if it was consistent the user might type the other
224
so we force it to uppercase
225
running python.exe under cmd.exe return capital C:\\
226
running win32 python inside a cygwin shell returns lowercase c:\\
228
drive, path = _nt_splitdrive(path)
229
return drive.upper() + path
232
def _win32_abspath(path):
233
# Real _nt_abspath doesn't have a problem with a unicode cwd
234
return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
237
def _win32_realpath(path):
238
# Real _nt_realpath doesn't have a problem with a unicode cwd
239
return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
242
def _win32_pathjoin(*args):
243
return _nt_join(*args).replace('\\', '/')
246
def _win32_normpath(path):
247
return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
251
return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
254
def _win32_mkdtemp(*args, **kwargs):
255
return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
258
def _win32_rename(old, new):
259
"""We expect to be able to atomically replace 'new' with old.
261
On win32, if new exists, it must be moved out of the way first,
265
fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
267
if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
268
# If we try to rename a non-existant file onto cwd, we get
269
# EPERM or EACCES instead of ENOENT, this will raise ENOENT
270
# if the old path doesn't exist, sometimes we get EACCES
271
# On Linux, we seem to get EBUSY, on Mac we get EINVAL
277
return unicodedata.normalize('NFKC', os.getcwdu())
280
# Default is to just use the python builtins, but these can be rebound on
281
# particular platforms.
282
abspath = _posix_abspath
283
realpath = _posix_realpath
284
pathjoin = os.path.join
285
normpath = os.path.normpath
287
mkdtemp = tempfile.mkdtemp
289
dirname = os.path.dirname
290
basename = os.path.basename
291
rmtree = shutil.rmtree
293
MIN_ABS_PATHLENGTH = 1
296
if sys.platform == 'win32':
297
abspath = _win32_abspath
298
realpath = _win32_realpath
299
pathjoin = _win32_pathjoin
300
normpath = _win32_normpath
301
getcwd = _win32_getcwd
302
mkdtemp = _win32_mkdtemp
303
rename = _win32_rename
305
MIN_ABS_PATHLENGTH = 3
307
def _win32_delete_readonly(function, path, excinfo):
308
"""Error handler for shutil.rmtree function [for win32]
309
Helps to remove files and dirs marked as read-only.
311
type_, value = excinfo[:2]
312
if function in (os.remove, os.rmdir) \
313
and type_ == OSError \
314
and value.errno == errno.EACCES:
315
bzrlib.osutils.make_writable(path)
320
def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
321
"""Replacer for shutil.rmtree: could remove readonly dirs/files"""
322
return shutil.rmtree(path, ignore_errors, onerror)
323
elif sys.platform == 'darwin':
327
def get_terminal_encoding():
328
"""Find the best encoding for printing to the screen.
330
This attempts to check both sys.stdout and sys.stdin to see
331
what encoding they are in, and if that fails it falls back to
332
bzrlib.user_encoding.
333
The problem is that on Windows, locale.getpreferredencoding()
334
is not the same encoding as that used by the console:
335
http://mail.python.org/pipermail/python-list/2003-May/162357.html
337
On my standard US Windows XP, the preferred encoding is
338
cp1252, but the console is cp437
340
output_encoding = getattr(sys.stdout, 'encoding', None)
341
if not output_encoding:
342
input_encoding = getattr(sys.stdin, 'encoding', None)
343
if not input_encoding:
344
output_encoding = bzrlib.user_encoding
345
mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
347
output_encoding = input_encoding
348
mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
350
mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
351
return output_encoding
101
if hasattr(os, 'lstat'):
107
if e.errno == errno.ENOENT:
110
raise BzrError("lstat/stat of (%r): %r" % (f, e))
354
112
def normalizepath(f):
355
113
if hasattr(os.path, 'realpath'):
359
117
[p,e] = os.path.split(f)
360
118
if e == "" or e == "." or e == "..":
363
return pathjoin(F(p), e)
121
return os.path.join(F(p), e)
123
if os.name == "posix":
124
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
125
# choke on a Unicode string containing a relative path if
126
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
128
_fs_enc = sys.getfilesystemencoding()
130
return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
132
return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
134
# We need to use the Unicode-aware os.path.abspath and
135
# os.path.realpath on Windows systems.
136
abspath = os.path.abspath
137
realpath = os.path.realpath
366
139
def backup_file(fn):
367
140
"""Copy a file to a backup.
759
480
s.insert(0, tail)
761
raise PathNotChild(rp, base)
769
def safe_unicode(unicode_or_utf8_string):
770
"""Coerce unicode_or_utf8_string into unicode.
772
If it is unicode, it is returned.
773
Otherwise it is decoded from utf-8. If a decoding error
774
occurs, it is wrapped as a If the decoding fails, the exception is wrapped
775
as a BzrBadParameter exception.
777
if isinstance(unicode_or_utf8_string, unicode):
778
return unicode_or_utf8_string
780
return unicode_or_utf8_string.decode('utf8')
781
except UnicodeDecodeError:
782
raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
785
_platform_normalizes_filenames = False
786
if sys.platform == 'darwin':
787
_platform_normalizes_filenames = True
790
def normalizes_filenames():
791
"""Return True if this platform normalizes unicode filenames.
793
Mac OSX does, Windows/Linux do not.
795
return _platform_normalizes_filenames
798
def _accessible_normalized_filename(path):
799
"""Get the unicode normalized path, and if you can access the file.
801
On platforms where the system normalizes filenames (Mac OSX),
802
you can access a file by any path which will normalize correctly.
803
On platforms where the system does not normalize filenames
804
(Windows, Linux), you have to access a file by its exact path.
806
Internally, bzr only supports NFC/NFKC normalization, since that is
807
the standard for XML documents.
809
So return the normalized path, and a flag indicating if the file
810
can be accessed by that path.
813
return unicodedata.normalize('NFKC', unicode(path)), True
816
def _inaccessible_normalized_filename(path):
817
__doc__ = _accessible_normalized_filename.__doc__
819
normalized = unicodedata.normalize('NFKC', unicode(path))
820
return normalized, normalized == path
823
if _platform_normalizes_filenames:
824
normalized_filename = _accessible_normalized_filename
826
normalized_filename = _inaccessible_normalized_filename
829
def terminal_width():
830
"""Return estimated terminal width."""
831
if sys.platform == 'win32':
832
import bzrlib.win32console
833
return bzrlib.win32console.get_console_size()[0]
836
import struct, fcntl, termios
837
s = struct.pack('HHHH', 0, 0, 0, 0)
838
x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
839
width = struct.unpack('HHHH', x)[1]
844
width = int(os.environ['COLUMNS'])
852
def supports_executable():
853
return sys.platform != "win32"
856
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
859
def check_legal_path(path):
860
"""Check whether the supplied path is legal.
861
This is only required on Windows, so we don't test on other platforms
864
if sys.platform != "win32":
866
if _validWin32PathRE.match(path) is None:
867
raise IllegalPath(path)
870
def walkdirs(top, prefix=""):
871
"""Yield data about all the directories in a tree.
873
This yields all the data about the contents of a directory at a time.
874
After each directory has been yielded, if the caller has mutated the list
875
to exclude some directories, they are then not descended into.
877
The data yielded is of the form:
878
[(relpath, basename, kind, lstat, path_from_top), ...]
880
:param prefix: Prefix the relpaths that are yielded with 'prefix'. This
881
allows one to walk a subtree but get paths that are relative to a tree
883
:return: an iterator over the dirs.
887
_directory = _directory_kind
889
pending = [(prefix, "", _directory, None, top)]
892
currentdir = pending.pop()
893
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
896
relroot = currentdir[0] + '/'
899
for name in sorted(_listdir(top)):
900
abspath = top + '/' + name
901
statvalue = lstat(abspath)
902
dirblock.append ((relroot + name, name, file_kind_from_stat_mode(statvalue.st_mode), statvalue, abspath))
904
# push the user specified dirs from dirblock
905
for dir in reversed(dirblock):
906
if dir[2] == _directory:
910
def path_prefix_key(path):
911
"""Generate a prefix-order path key for path.
913
This can be used to sort paths in the same way that walkdirs does.
915
return (dirname(path) , path)
918
def compare_paths_prefix_order(path_a, path_b):
919
"""Compare path_a and path_b to generate the same order walkdirs uses."""
920
key_a = path_prefix_key(path_a)
921
key_b = path_prefix_key(path_b)
922
return cmp(key_a, key_b)
482
# XXX This should raise a NotChildPath exception, as its not tied
484
raise NotBranchError("path %r is not within branch %r" % (rp, base))
486
return os.sep.join(s)
added
removed
bzrlib/osutils.py
