← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

(mbp) merge bzr.dev to 0.8, prepare for release

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
24
24
import os
25
25
import re
26
26
import sha
 
27
import shutil
27
28
import string
28
29
import sys
29
30
import time
30
31
import types
 
32
import tempfile
31
33
 
32
34
import bzrlib
33
 
from bzrlib.errors import BzrError, NotBranchError
 
35
from bzrlib.errors import (BzrError,
 
36
                           BzrBadParameterNotUnicode,
 
37
                           NoSuchFile,
 
38
                           PathNotChild,
 
39
                           IllegalPath,
 
40
                           )
34
41
from bzrlib.trace import mutter
35
42
 
36
43
 
97
104
        raise BzrError('invalid file kind %r' % kind)
98
105
 
99
106
def lexists(f):
 
107
    if hasattr(os.path, 'lexists'):
 
108
        return os.path.lexists(f)
100
109
    try:
101
110
        if hasattr(os, 'lstat'):
102
111
            os.lstat(f)
109
118
        else:
110
119
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
111
120
 
112
 
def normalizepath(f):
113
 
    if hasattr(os.path, 'realpath'):
114
 
        F = os.path.realpath
115
 
    else:
116
 
        F = os.path.abspath
117
 
    [p,e] = os.path.split(f)
118
 
    if e == "" or e == "." or e == "..":
119
 
        return F(f)
120
 
    else:
121
 
        return os.path.join(F(p), e)
 
121
def fancy_rename(old, new, rename_func, unlink_func):
 
122
    """A fancy rename, when you don't have atomic rename.
 
123
    
 
124
    :param old: The old path, to rename from
 
125
    :param new: The new path, to rename to
 
126
    :param rename_func: The potentially non-atomic rename function
 
127
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
128
    """
 
129
 
 
130
    # sftp rename doesn't allow overwriting, so play tricks:
 
131
    import random
 
132
    base = os.path.basename(new)
 
133
    dirname = os.path.dirname(new)
 
134
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
135
    tmp_name = pathjoin(dirname, tmp_name)
 
136
 
 
137
    # Rename the file out of the way, but keep track if it didn't exist
 
138
    # We don't want to grab just any exception
 
139
    # something like EACCES should prevent us from continuing
 
140
    # The downside is that the rename_func has to throw an exception
 
141
    # with an errno = ENOENT, or NoSuchFile
 
142
    file_existed = False
 
143
    try:
 
144
        rename_func(new, tmp_name)
 
145
    except (NoSuchFile,), e:
 
146
        pass
 
147
    except IOError, e:
 
148
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
 
149
        # function raises an IOError with errno == None when a rename fails.
 
150
        # This then gets caught here.
 
151
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
 
152
            raise
 
153
    except Exception, e:
 
154
        if (not hasattr(e, 'errno') 
 
155
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
156
            raise
 
157
    else:
 
158
        file_existed = True
 
159
 
 
160
    success = False
 
161
    try:
 
162
        # This may throw an exception, in which case success will
 
163
        # not be set.
 
164
        rename_func(old, new)
 
165
        success = True
 
166
    finally:
 
167
        if file_existed:
 
168
            # If the file used to exist, rename it back into place
 
169
            # otherwise just delete it from the tmp location
 
170
            if success:
 
171
                unlink_func(tmp_name)
 
172
            else:
 
173
                rename_func(tmp_name, new)
 
174
 
 
175
# Default is to just use the python builtins, but these can be rebound on
 
176
# particular platforms.
 
177
abspath = os.path.abspath
 
178
realpath = os.path.realpath
 
179
pathjoin = os.path.join
 
180
normpath = os.path.normpath
 
181
getcwd = os.getcwdu
 
182
mkdtemp = tempfile.mkdtemp
 
183
rename = os.rename
 
184
dirname = os.path.dirname
 
185
basename = os.path.basename
 
186
rmtree = shutil.rmtree
 
187
 
 
188
MIN_ABS_PATHLENGTH = 1
122
189
 
123
190
if os.name == "posix":
124
191
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
128
195
    _fs_enc = sys.getfilesystemencoding()
129
196
    def abspath(path):
130
197
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
198
 
131
199
    def realpath(path):
132
200
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
133
 
else:
 
201
 
 
202
if sys.platform == 'win32':
134
203
    # We need to use the Unicode-aware os.path.abspath and
135
204
    # os.path.realpath on Windows systems.
136
 
    abspath = os.path.abspath
137
 
    realpath = os.path.realpath
 
205
    def abspath(path):
 
206
        return os.path.abspath(path).replace('\\', '/')
 
207
 
 
208
    def realpath(path):
 
209
        return os.path.realpath(path).replace('\\', '/')
 
210
 
 
211
    def pathjoin(*args):
 
212
        return os.path.join(*args).replace('\\', '/')
 
213
 
 
214
    def normpath(path):
 
215
        return os.path.normpath(path).replace('\\', '/')
 
216
 
 
217
    def getcwd():
 
218
        return os.getcwdu().replace('\\', '/')
 
219
 
 
220
    def mkdtemp(*args, **kwargs):
 
221
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
222
 
 
223
    def rename(old, new):
 
224
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
225
 
 
226
    MIN_ABS_PATHLENGTH = 3
 
227
 
 
228
    def _win32_delete_readonly(function, path, excinfo):
 
229
        """Error handler for shutil.rmtree function [for win32]
 
230
        Helps to remove files and dirs marked as read-only.
 
231
        """
 
232
        type_, value = excinfo[:2]
 
233
        if function in (os.remove, os.rmdir) \
 
234
            and type_ == OSError \
 
235
            and value.errno == errno.EACCES:
 
236
            bzrlib.osutils.make_writable(path)
 
237
            function(path)
 
238
        else:
 
239
            raise
 
240
 
 
241
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
 
242
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
 
243
        return shutil.rmtree(path, ignore_errors, onerror)
 
244
 
 
245
 
 
246
def normalizepath(f):
 
247
    if hasattr(os.path, 'realpath'):
 
248
        F = realpath
 
249
    else:
 
250
        F = abspath
 
251
    [p,e] = os.path.split(f)
 
252
    if e == "" or e == "." or e == "..":
 
253
        return F(f)
 
254
    else:
 
255
        return pathjoin(F(p), e)
 
256
 
138
257
 
139
258
def backup_file(fn):
140
259
    """Copy a file to a backup.
163
282
    finally:
164
283
        outf.close()
165
284
 
166
 
if os.name == 'nt':
167
 
    import shutil
168
 
    rename = shutil.move
169
 
else:
170
 
    rename = os.rename
171
 
 
172
285
 
173
286
def isdir(f):
174
287
    """True if f is an accessible directory."""
195
308
def is_inside(dir, fname):
196
309
    """True if fname is inside dir.
197
310
    
198
 
    The parameters should typically be passed to os.path.normpath first, so
 
311
    The parameters should typically be passed to osutils.normpath first, so
199
312
    that . and .. and repeated slashes are eliminated, and the separators
200
313
    are canonical for the platform.
201
314
    
202
315
    The empty string as a dir name is taken as top-of-tree and matches 
203
316
    everything.
204
317
    
205
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
318
    >>> is_inside('src', pathjoin('src', 'foo.c'))
206
319
    True
207
320
    >>> is_inside('src', 'srccontrol')
208
321
    False
209
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
322
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
210
323
    True
211
324
    >>> is_inside('foo.c', 'foo.c')
212
325
    True
223
336
    if dir == '':
224
337
        return True
225
338
 
226
 
    if dir[-1] != os.sep:
227
 
        dir += os.sep
 
339
    if dir[-1] != '/':
 
340
        dir += '/'
228
341
 
229
342
    return fname.startswith(dir)
230
343
 
240
353
 
241
354
def pumpfile(fromfile, tofile):
242
355
    """Copy contents of one file to another."""
243
 
    tofile.write(fromfile.read())
 
356
    BUFSIZE = 32768
 
357
    while True:
 
358
        b = fromfile.read(BUFSIZE)
 
359
        if not b:
 
360
            break
 
361
        tofile.write(b)
 
362
 
 
363
 
 
364
def file_iterator(input_file, readsize=32768):
 
365
    while True:
 
366
        b = input_file.read(readsize)
 
367
        if len(b) == 0:
 
368
            break
 
369
        yield b
244
370
 
245
371
 
246
372
def sha_file(f):
340
466
    """Return size of given open file."""
341
467
    return os.fstat(f.fileno())[ST_SIZE]
342
468
 
 
469
 
343
470
# Define rand_bytes based on platform.
344
471
try:
345
472
    # Python 2.4 and later have os.urandom,
362
489
                n -= 1
363
490
            return s
364
491
 
 
492
 
 
493
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
 
494
def rand_chars(num):
 
495
    """Return a random string of num alphanumeric characters
 
496
    
 
497
    The result only contains lowercase chars because it may be used on 
 
498
    case-insensitive filesystems.
 
499
    """
 
500
    s = ''
 
501
    for raw_byte in rand_bytes(num):
 
502
        s += ALNUM[ord(raw_byte) % 36]
 
503
    return s
 
504
 
 
505
 
365
506
## TODO: We could later have path objects that remember their list
366
507
## decomposition (might be too tricksy though.)
367
508
 
402
543
    for f in p:
403
544
        if (f == '..') or (f == None) or (f == ''):
404
545
            raise BzrError("sorry, %r not allowed in path" % f)
405
 
    return os.path.join(*p)
 
546
    return pathjoin(*p)
406
547
 
407
548
 
408
549
def appendpath(p1, p2):
409
550
    if p1 == '':
410
551
        return p2
411
552
    else:
412
 
        return os.path.join(p1, p2)
 
553
        return pathjoin(p1, p2)
413
554
    
414
555
 
415
556
def split_lines(s):
416
557
    """Split s into lines, but without removing the newline characters."""
417
 
    return StringIO(s).readlines()
 
558
    lines = s.split('\n')
 
559
    result = [line + '\n' for line in lines[:-1]]
 
560
    if lines[-1]:
 
561
        result.append(lines[-1])
 
562
    return result
418
563
 
419
564
 
420
565
def hardlinks_good():
433
578
            raise
434
579
        copyfile(src, dest)
435
580
 
 
581
def delete_any(full_path):
 
582
    """Delete a file or directory."""
 
583
    try:
 
584
        os.unlink(full_path)
 
585
    except OSError, e:
 
586
    # We may be renaming a dangling inventory id
 
587
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
588
            raise
 
589
        os.rmdir(full_path)
 
590
 
436
591
 
437
592
def has_symlinks():
438
593
    if hasattr(os, 'symlink'):
467
622
 
468
623
    os.path.commonprefix (python2.4) has a bad bug that it works just
469
624
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
470
 
    avoids that problem."""
 
625
    avoids that problem.
 
626
    """
 
627
 
 
628
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
 
629
        ' exceed the platform minimum length (which is %d)' % 
 
630
        MIN_ABS_PATHLENGTH)
471
631
    rp = abspath(path)
472
632
 
473
633
    s = []
481
641
    else:
482
642
        # XXX This should raise a NotChildPath exception, as its not tied
483
643
        # to branch anymore.
484
 
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
485
 
 
486
 
    return os.sep.join(s)
 
644
        raise PathNotChild(rp, base)
 
645
 
 
646
    if s:
 
647
        return pathjoin(*s)
 
648
    else:
 
649
        return ''
 
650
 
 
651
 
 
652
def safe_unicode(unicode_or_utf8_string):
 
653
    """Coerce unicode_or_utf8_string into unicode.
 
654
 
 
655
    If it is unicode, it is returned.
 
656
    Otherwise it is decoded from utf-8. If a decoding error
 
657
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
658
    as a BzrBadParameter exception.
 
659
    """
 
660
    if isinstance(unicode_or_utf8_string, unicode):
 
661
        return unicode_or_utf8_string
 
662
    try:
 
663
        return unicode_or_utf8_string.decode('utf8')
 
664
    except UnicodeDecodeError:
 
665
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
666
 
 
667
 
 
668
def terminal_width():
 
669
    """Return estimated terminal width."""
 
670
 
 
671
    # TODO: Do something smart on Windows?
 
672
 
 
673
    # TODO: Is there anything that gets a better update when the window
 
674
    # is resized while the program is running? We could use the Python termcap
 
675
    # library.
 
676
    try:
 
677
        return int(os.environ['COLUMNS'])
 
678
    except (IndexError, KeyError, ValueError):
 
679
        return 80
 
680
 
 
681
def supports_executable():
 
682
    return sys.platform != "win32"
 
683
 
 
684
 
 
685
def strip_trailing_slash(path):
 
686
    """Strip trailing slash, except for root paths.
 
687
    The definition of 'root path' is platform-dependent.
 
688
    """
 
689
    if len(path) != MIN_ABS_PATHLENGTH and path[-1] == '/':
 
690
        return path[:-1]
 
691
    else:
 
692
        return path
 
693
 
 
694
 
 
695
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
 
696
 
 
697
 
 
698
def check_legal_path(path):
 
699
    """Check whether the supplied path is legal.  
 
700
    This is only required on Windows, so we don't test on other platforms
 
701
    right now.
 
702
    """
 
703
    if sys.platform != "win32":
 
704
        return
 
705
    if _validWin32PathRE.match(path) is None:
 
706
        raise IllegalPath(path)