1
# Bazaar-NG -- distributed version control
3
# Copyright (C) 2005 by Canonical Ltd
5
# This program is free software; you can redistribute it and/or modify
6
# it under the terms of the GNU General Public License as published by
7
# the Free Software Foundation; either version 2 of the License, or
8
# (at your option) any later version.
10
# This program is distributed in the hope that it will be useful,
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
# GNU General Public License for more details.
15
# You should have received a copy of the GNU General Public License
16
# along with this program; if not, write to the Free Software
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
from shutil import copyfile
20
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
22
from cStringIO import StringIO
36
from bzrlib.errors import (BzrError,
37
BzrBadParameterNotUnicode,
43
from bzrlib.trace import mutter
46
def make_readonly(filename):
47
"""Make a filename read-only."""
48
mod = os.stat(filename).st_mode
50
os.chmod(filename, mod)
53
def make_writable(filename):
54
mod = os.stat(filename).st_mode
56
os.chmod(filename, mod)
63
"""Return a quoted filename filename
65
This previously used backslash quoting, but that works poorly on
67
# TODO: I'm not really sure this is the best format either.x
70
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
72
if _QUOTE_RE.search(f):
79
mode = os.lstat(f)[ST_MODE]
98
def kind_marker(kind):
101
elif kind == 'directory':
103
elif kind == 'symlink':
106
raise BzrError('invalid file kind %r' % kind)
109
if hasattr(os.path, 'lexists'):
110
return os.path.lexists(f)
112
if hasattr(os, 'lstat'):
118
if e.errno == errno.ENOENT:
121
raise BzrError("lstat/stat of (%r): %r" % (f, e))
123
def fancy_rename(old, new, rename_func, unlink_func):
124
"""A fancy rename, when you don't have atomic rename.
126
:param old: The old path, to rename from
127
:param new: The new path, to rename to
128
:param rename_func: The potentially non-atomic rename function
129
:param unlink_func: A way to delete the target file if the full rename succeeds
132
# sftp rename doesn't allow overwriting, so play tricks:
134
base = os.path.basename(new)
135
dirname = os.path.dirname(new)
136
tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
137
tmp_name = pathjoin(dirname, tmp_name)
139
# Rename the file out of the way, but keep track if it didn't exist
140
# We don't want to grab just any exception
141
# something like EACCES should prevent us from continuing
142
# The downside is that the rename_func has to throw an exception
143
# with an errno = ENOENT, or NoSuchFile
146
rename_func(new, tmp_name)
147
except (NoSuchFile,), e:
150
# RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
151
# function raises an IOError with errno == None when a rename fails.
152
# This then gets caught here.
153
if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
156
if (not hasattr(e, 'errno')
157
or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
164
# This may throw an exception, in which case success will
166
rename_func(old, new)
170
# If the file used to exist, rename it back into place
171
# otherwise just delete it from the tmp location
173
unlink_func(tmp_name)
175
rename_func(tmp_name, new)
178
def urlescape(relpath):
179
"""Escape relpath to be a valid url."""
180
if isinstance(relpath, unicode):
181
relpath = relpath.encode('utf-8')
182
# After quoting and encoding, the path should be perfectly
183
# safe as a plain ASCII string, str() just enforces this
184
return str(urllib.quote(relpath))
187
def urlunescape(url):
188
"""Unescape relpath from url format.
190
This returns a Unicode path from a URL
192
# jam 20060427 URLs are supposed to be ASCII only strings
193
# If they are passed in as unicode, urllib.unquote
194
# will return a UNICODE string, which actually contains
195
# utf-8 bytes. So we have to ensure that they are
196
# plain ASCII strings, or the final .decode will
197
# try to encode the UNICODE => ASCII, and then decode
201
except UnicodeError, e:
202
raise InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
203
unquoted = urllib.unquote(url)
205
unicode_path = unquoted.decode('utf-8')
206
except UnicodeError, e:
207
raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
211
def _posix_local_path_to_url(path):
212
"""Convert a local path like ./foo into a URL like file:///path/to/foo
214
This also handles transforming escaping unicode characters, etc.
216
# importing directly from posixpath allows us to test this
217
# on non-posix platforms
218
from posixpath import normpath
219
return 'file://' + urlescape(normpath(_posix_abspath(path)))
222
def _posix_local_path_from_url(url):
223
"""Convert a url like file:///path/to/foo into /path/to/foo"""
224
if not url.startswith('file:///'):
225
raise InvalidURL(url, 'local urls must start with file:///')
226
# We only strip off 2 slashes
227
return urlunescape(url[len('file://'):])
230
def _win32_local_path_to_url(path):
231
"""Convert a local path like ./foo into a URL like file:///C|/path/to/foo
233
This also handles transforming escaping unicode characters, etc.
235
# importing directly from ntpath allows us to test this
236
# on non-win32 platforms
237
# TODO: jam 20060426 consider moving this import outside of the function
238
from ntpath import normpath
239
win32_path = normpath(abspath(path)).replace('\\', '/')
240
return 'file:///' + win32_path[0] + '|' + urlescape(win32_path[2:])
243
def _win32_local_path_from_url(url):
244
"""Convert a url like file:///C|/path/to/foo into C:/path/to/foo"""
245
if not url.startswith('file:///'):
246
raise InvalidURL(url, 'local urls must start with file:///')
247
# We strip off all 3 slashes
248
win32_url = url[len('file:///'):]
249
if (win32_url[0] not in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
250
or win32_url[1] != '|'
251
or win32_url[2] != '/'):
252
raise InvalidURL(url, 'Win32 file urls start with file:///X|/, where X is a valid drive letter')
253
# TODO: jam 20060426, we could .upper() or .lower() the drive letter
254
# for better consistency.
255
return win32_url[0] + u':' + urlunescape(win32_url[2:])
258
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
259
# choke on a Unicode string containing a relative path if
260
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
262
_fs_enc = sys.getfilesystemencoding()
263
def _posix_abspath(path):
264
return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
267
def _posix_realpath(path):
268
return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
271
def _win32_abspath(path):
272
return _posix_abspath(path).replace('\\', '/')
275
def _win32_realpath(path):
276
return _posix_realpath(path).replace('\\', '/')
279
def _win32_pathjoin(*args):
280
return os.path.join(*args).replace('\\', '/')
283
def _win32_normpath(path):
284
return os.path.normpath(path).replace('\\', '/')
288
return os.getcwdu().replace('\\', '/')
291
def _win32_mkdtemp(*args, **kwargs):
292
return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
295
def _win32_rename(old, new):
296
fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
299
# Default is to just use the python builtins
300
abspath = _posix_abspath
301
realpath = _posix_realpath
302
pathjoin = os.path.join
303
normpath = os.path.normpath
305
mkdtemp = tempfile.mkdtemp
307
dirname = os.path.dirname
308
basename = os.path.basename
309
local_path_to_url = _posix_local_path_to_url
310
local_path_from_url = _posix_local_path_from_url
312
MIN_ABS_PATHLENGTH = 1
313
MIN_ABS_URLPATHLENGTH = len('file:///')
317
if sys.platform == 'win32':
318
abspath = _win32_abspath
319
realpath = _win32_realpath
320
pathjoin = _win32_pathjoin
321
normpath = _win32_normpath
322
getcwd = _win32_getcwd
323
mkdtemp = _win32_mkdtemp
324
rename = _win32_rename
326
local_path_to_url = _win32_local_path_to_url
327
local_path_from_url = _win32_local_path_from_url
329
MIN_ABS_PATHLENGTH = 3
330
MIN_ABS_URLPATHLENGTH = len('file:///C|/')
332
def normalizepath(f):
333
if hasattr(os.path, 'realpath'):
337
[p,e] = os.path.split(f)
338
if e == "" or e == "." or e == "..":
341
return pathjoin(F(p), e)
345
"""Copy a file to a backup.
347
Backups are named in GNU-style, with a ~ suffix.
349
If the file is already a backup, it's not copied.
355
if has_symlinks() and os.path.islink(fn):
356
target = os.readlink(fn)
357
os.symlink(target, bfn)
365
outf = file(bfn, 'wb')
373
"""True if f is an accessible directory."""
375
return S_ISDIR(os.lstat(f)[ST_MODE])
381
"""True if f is a regular file."""
383
return S_ISREG(os.lstat(f)[ST_MODE])
388
"""True if f is a symlink."""
390
return S_ISLNK(os.lstat(f)[ST_MODE])
394
def is_inside(dir, fname):
395
"""True if fname is inside dir.
397
The parameters should typically be passed to osutils.normpath first, so
398
that . and .. and repeated slashes are eliminated, and the separators
399
are canonical for the platform.
401
The empty string as a dir name is taken as top-of-tree and matches
404
>>> is_inside('src', pathjoin('src', 'foo.c'))
406
>>> is_inside('src', 'srccontrol')
408
>>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
410
>>> is_inside('foo.c', 'foo.c')
412
>>> is_inside('foo.c', '')
414
>>> is_inside('', 'foo.c')
417
# XXX: Most callers of this can actually do something smarter by
418
# looking at the inventory
428
return fname.startswith(dir)
431
def is_inside_any(dir_list, fname):
432
"""True if fname is inside any of given dirs."""
433
for dirname in dir_list:
434
if is_inside(dirname, fname):
440
def pumpfile(fromfile, tofile):
441
"""Copy contents of one file to another."""
444
b = fromfile.read(BUFSIZE)
450
def file_iterator(input_file, readsize=32768):
452
b = input_file.read(readsize)
459
if hasattr(f, 'tell'):
472
def sha_strings(strings):
473
"""Return the sha-1 of concatenation of strings"""
475
map(s.update, strings)
485
def fingerprint_file(f):
490
return {'size': size,
491
'sha1': s.hexdigest()}
494
def compare_files(a, b):
495
"""Returns true if equal in contents"""
506
def local_time_offset(t=None):
507
"""Return offset of local zone from GMT, either at present or at time t."""
508
# python2.3 localtime() can't take None
512
if time.localtime(t).tm_isdst and time.daylight:
515
return -time.timezone
518
def format_date(t, offset=0, timezone='original', date_fmt=None,
520
## TODO: Perhaps a global option to use either universal or local time?
521
## Or perhaps just let people set $TZ?
522
assert isinstance(t, float)
524
if timezone == 'utc':
527
elif timezone == 'original':
530
tt = time.gmtime(t + offset)
531
elif timezone == 'local':
532
tt = time.localtime(t)
533
offset = local_time_offset(t)
535
raise BzrError("unsupported timezone format %r" % timezone,
536
['options are "utc", "original", "local"'])
538
date_fmt = "%a %Y-%m-%d %H:%M:%S"
540
offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
543
return (time.strftime(date_fmt, tt) + offset_str)
546
def compact_date(when):
547
return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
552
"""Return size of given open file."""
553
return os.fstat(f.fileno())[ST_SIZE]
556
# Define rand_bytes based on platform.
558
# Python 2.4 and later have os.urandom,
559
# but it doesn't work on some arches
561
rand_bytes = os.urandom
562
except (NotImplementedError, AttributeError):
563
# If python doesn't have os.urandom, or it doesn't work,
564
# then try to first pull random data from /dev/urandom
565
if os.path.exists("/dev/urandom"):
566
rand_bytes = file('/dev/urandom', 'rb').read
567
# Otherwise, use this hack as a last resort
569
# not well seeded, but better than nothing
574
s += chr(random.randint(0, 255))
579
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
581
"""Return a random string of num alphanumeric characters
583
The result only contains lowercase chars because it may be used on
584
case-insensitive filesystems.
587
for raw_byte in rand_bytes(num):
588
s += ALNUM[ord(raw_byte) % 36]
592
## TODO: We could later have path objects that remember their list
593
## decomposition (might be too tricksy though.)
596
"""Turn string into list of parts.
602
>>> splitpath('a/./b')
604
>>> splitpath('a/.b')
606
>>> splitpath('a/../b')
607
Traceback (most recent call last):
609
BzrError: sorry, '..' not allowed in path
611
assert isinstance(p, types.StringTypes)
613
# split on either delimiter because people might use either on
615
ps = re.split(r'[\\/]', p)
620
raise BzrError("sorry, %r not allowed in path" % f)
621
elif (f == '.') or (f == ''):
628
assert isinstance(p, list)
630
if (f == '..') or (f == None) or (f == ''):
631
raise BzrError("sorry, %r not allowed in path" % f)
635
def appendpath(p1, p2):
639
return pathjoin(p1, p2)
643
"""Split s into lines, but without removing the newline characters."""
644
lines = s.split('\n')
645
result = [line + '\n' for line in lines[:-1]]
647
result.append(lines[-1])
651
def hardlinks_good():
652
return sys.platform not in ('win32', 'cygwin', 'darwin')
655
def link_or_copy(src, dest):
656
"""Hardlink a file, or copy it if it can't be hardlinked."""
657
if not hardlinks_good():
662
except (OSError, IOError), e:
663
if e.errno != errno.EXDEV:
667
def delete_any(full_path):
668
"""Delete a file or directory."""
672
# We may be renaming a dangling inventory id
673
if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
679
if hasattr(os, 'symlink'):
685
def contains_whitespace(s):
686
"""True if there are any whitespace characters in s."""
687
for ch in string.whitespace:
694
def contains_linebreaks(s):
695
"""True if there is any vertical whitespace in s."""
703
def relpath(base, path):
704
"""Return path relative to base, or raise exception.
706
The path may be either an absolute path or a path relative to the
707
current working directory.
709
os.path.commonprefix (python2.4) has a bad bug that it works just
710
on string prefixes, assuming that '/u' is a prefix of '/u2'. This
714
assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
715
' exceed the platform minimum length (which is %d)' %
722
while len(head) >= len(base):
725
head, tail = os.path.split(head)
729
raise PathNotChild(rp, base)
737
def urlrelpath(base, path):
738
"""Compute just the relative sub-portion of a url
740
This assumes that both paths are already fully specified file:// URLs.
742
assert len(base) >= MIN_ABS_URLPATHLENGTH, ('Length of base must be equal or'
743
' exceed the platform minimum url length (which is %d)' %
744
MIN_ABS_URLPATHLENGTH)
746
base = local_path_from_url(base)
747
path = local_path_from_url(path)
748
return urlescape(relpath(base, path))
751
def safe_unicode(unicode_or_utf8_string):
752
"""Coerce unicode_or_utf8_string into unicode.
754
If it is unicode, it is returned.
755
Otherwise it is decoded from utf-8. If a decoding error
756
occurs, it is wrapped as a If the decoding fails, the exception is wrapped
757
as a BzrBadParameter exception.
759
if isinstance(unicode_or_utf8_string, unicode):
760
return unicode_or_utf8_string
762
return unicode_or_utf8_string.decode('utf8')
763
except UnicodeDecodeError:
764
raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
767
_platform_normalizes_filenames = False
768
if sys.platform == 'darwin':
769
_platform_normalizes_filenames = True
772
def normalizes_filenames():
773
"""Return True if this platform normalizes unicode filenames.
775
Mac OSX does, Windows/Linux do not.
777
return _platform_normalizes_filenames
780
if _platform_normalizes_filenames:
781
def unicode_filename(path):
782
"""Make sure 'path' is a properly normalized filename.
784
On platforms where the system normalizes filenames (Mac OSX),
785
you can access a file by any path which will normalize
787
Internally, bzr only supports NFC/NFKC normalization, since
788
that is the standard for XML documents.
789
So we return an normalized path, and indicate this has been
792
:return: (path, is_normalized) Return a path which can
793
access the file, and whether or not this path is
796
return unicodedata.normalize('NFKC', path), True
798
def unicode_filename(path):
799
"""Make sure 'path' is a properly normalized filename.
801
On platforms where the system does not normalize filenames
802
(Windows, Linux), you have to access a file by its exact path.
803
Internally, bzr only supports NFC/NFKC normalization, since
804
that is the standard for XML documents.
805
So we return the original path, and indicate if this is
808
:return: (path, is_normalized) Return a path which can
809
access the file, and whether or not this path is
812
return path, unicodedata.normalize('NFKC', path) == path
815
def terminal_width():
816
"""Return estimated terminal width."""
818
# TODO: Do something smart on Windows?
820
# TODO: Is there anything that gets a better update when the window
821
# is resized while the program is running? We could use the Python termcap
824
return int(os.environ['COLUMNS'])
825
except (IndexError, KeyError, ValueError):
828
def supports_executable():
829
return sys.platform != "win32"
832
def strip_url_trailing_slash(path):
833
"""Strip trailing slash, except for root paths.
834
The definition of 'root path' is platform-dependent.
836
assert path.startswith('file:///'), \
837
'strip_url_trailing_slash expects file:// urls (%s)' % path
838
if len(path) != MIN_ABS_URLPATHLENGTH and path[-1] == '/':
844
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
847
def check_legal_path(path):
848
"""Check whether the supplied path is legal.
849
This is only required on Windows, so we don't test on other platforms
852
if sys.platform != "win32":
854
if _validWin32PathRE.match(path) is None:
855
raise IllegalPath(path)
added
removed
bzrlib/osutils.py
