← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2005-10-18 05:26:22 UTC
  • mto: This revision was merged to the branch mainline in revision 1463.
  • Revision ID: robertc@robertcollins.net-20051018052622-653d638c9e26fde4
fix broken tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
28
28
import sys
29
29
import time
30
30
import types
31
 
import tempfile
32
31
 
33
32
import bzrlib
34
 
from bzrlib.errors import (BzrError,
35
 
                           BzrBadParameterNotUnicode,
36
 
                           NoSuchFile,
37
 
                           PathNotChild,
38
 
                           IllegalPath,
39
 
                           )
 
33
from bzrlib.errors import BzrError, NotBranchError
40
34
from bzrlib.trace import mutter
41
35
 
42
36
 
103
97
        raise BzrError('invalid file kind %r' % kind)
104
98
 
105
99
def lexists(f):
106
 
    if hasattr(os.path, 'lexists'):
107
 
        return os.path.lexists(f)
108
100
    try:
109
101
        if hasattr(os, 'lstat'):
110
102
            os.lstat(f)
117
109
        else:
118
110
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
119
111
 
120
 
def fancy_rename(old, new, rename_func, unlink_func):
121
 
    """A fancy rename, when you don't have atomic rename.
122
 
    
123
 
    :param old: The old path, to rename from
124
 
    :param new: The new path, to rename to
125
 
    :param rename_func: The potentially non-atomic rename function
126
 
    :param unlink_func: A way to delete the target file if the full rename succeeds
127
 
    """
128
 
 
129
 
    # sftp rename doesn't allow overwriting, so play tricks:
130
 
    import random
131
 
    base = os.path.basename(new)
132
 
    dirname = os.path.dirname(new)
133
 
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
134
 
    tmp_name = pathjoin(dirname, tmp_name)
135
 
 
136
 
    # Rename the file out of the way, but keep track if it didn't exist
137
 
    # We don't want to grab just any exception
138
 
    # something like EACCES should prevent us from continuing
139
 
    # The downside is that the rename_func has to throw an exception
140
 
    # with an errno = ENOENT, or NoSuchFile
141
 
    file_existed = False
142
 
    try:
143
 
        rename_func(new, tmp_name)
144
 
    except (NoSuchFile,), e:
145
 
        pass
146
 
    except IOError, e:
147
 
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
148
 
        # function raises an IOError with errno == None when a rename fails.
149
 
        # This then gets caught here.
150
 
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
151
 
            raise
152
 
    except Exception, e:
153
 
        if (not hasattr(e, 'errno') 
154
 
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
155
 
            raise
156
 
    else:
157
 
        file_existed = True
158
 
 
159
 
    success = False
160
 
    try:
161
 
        # This may throw an exception, in which case success will
162
 
        # not be set.
163
 
        rename_func(old, new)
164
 
        success = True
165
 
    finally:
166
 
        if file_existed:
167
 
            # If the file used to exist, rename it back into place
168
 
            # otherwise just delete it from the tmp location
169
 
            if success:
170
 
                unlink_func(tmp_name)
171
 
            else:
172
 
                rename_func(tmp_name, new)
173
 
 
174
 
# Default is to just use the python builtins
175
 
abspath = os.path.abspath
176
 
realpath = os.path.realpath
177
 
pathjoin = os.path.join
178
 
normpath = os.path.normpath
179
 
getcwd = os.getcwdu
180
 
mkdtemp = tempfile.mkdtemp
181
 
rename = os.rename
182
 
dirname = os.path.dirname
183
 
basename = os.path.basename
184
 
 
185
 
MIN_ABS_PATHLENGTH = 1
186
 
 
187
 
if os.name == "posix":
188
 
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
189
 
    # choke on a Unicode string containing a relative path if
190
 
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
191
 
    # string.
192
 
    _fs_enc = sys.getfilesystemencoding()
193
 
    def abspath(path):
194
 
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
195
 
 
196
 
    def realpath(path):
197
 
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
198
 
 
199
 
if sys.platform == 'win32':
200
 
    # We need to use the Unicode-aware os.path.abspath and
201
 
    # os.path.realpath on Windows systems.
202
 
    def abspath(path):
203
 
        return os.path.abspath(path).replace('\\', '/')
204
 
 
205
 
    def realpath(path):
206
 
        return os.path.realpath(path).replace('\\', '/')
207
 
 
208
 
    def pathjoin(*args):
209
 
        return os.path.join(*args).replace('\\', '/')
210
 
 
211
 
    def normpath(path):
212
 
        return os.path.normpath(path).replace('\\', '/')
213
 
 
214
 
    def getcwd():
215
 
        return os.getcwdu().replace('\\', '/')
216
 
 
217
 
    def mkdtemp(*args, **kwargs):
218
 
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
219
 
 
220
 
    def rename(old, new):
221
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
222
 
 
223
 
    MIN_ABS_PATHLENGTH = 3
224
 
 
225
112
def normalizepath(f):
226
113
    if hasattr(os.path, 'realpath'):
227
 
        F = realpath
 
114
        F = os.path.realpath
228
115
    else:
229
 
        F = abspath
 
116
        F = os.path.abspath
230
117
    [p,e] = os.path.split(f)
231
118
    if e == "" or e == "." or e == "..":
232
119
        return F(f)
233
120
    else:
234
 
        return pathjoin(F(p), e)
235
 
 
 
121
        return os.path.join(F(p), e)
 
122
    
236
123
 
237
124
def backup_file(fn):
238
125
    """Copy a file to a backup.
261
148
    finally:
262
149
        outf.close()
263
150
 
 
151
if os.name == 'nt':
 
152
    import shutil
 
153
    rename = shutil.move
 
154
else:
 
155
    rename = os.rename
 
156
 
264
157
 
265
158
def isdir(f):
266
159
    """True if f is an accessible directory."""
287
180
def is_inside(dir, fname):
288
181
    """True if fname is inside dir.
289
182
    
290
 
    The parameters should typically be passed to osutils.normpath first, so
 
183
    The parameters should typically be passed to os.path.normpath first, so
291
184
    that . and .. and repeated slashes are eliminated, and the separators
292
185
    are canonical for the platform.
293
186
    
294
187
    The empty string as a dir name is taken as top-of-tree and matches 
295
188
    everything.
296
189
    
297
 
    >>> is_inside('src', pathjoin('src', 'foo.c'))
 
190
    >>> is_inside('src', os.path.join('src', 'foo.c'))
298
191
    True
299
192
    >>> is_inside('src', 'srccontrol')
300
193
    False
301
 
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
 
194
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
302
195
    True
303
196
    >>> is_inside('foo.c', 'foo.c')
304
197
    True
315
208
    if dir == '':
316
209
        return True
317
210
 
318
 
    if dir[-1] != '/':
319
 
        dir += '/'
 
211
    if dir[-1] != os.sep:
 
212
        dir += os.sep
320
213
 
321
214
    return fname.startswith(dir)
322
215
 
332
225
 
333
226
def pumpfile(fromfile, tofile):
334
227
    """Copy contents of one file to another."""
335
 
    BUFSIZE = 32768
336
 
    while True:
337
 
        b = fromfile.read(BUFSIZE)
338
 
        if not b:
339
 
            break
340
 
        tofile.write(b)
341
 
 
342
 
 
343
 
def file_iterator(input_file, readsize=32768):
344
 
    while True:
345
 
        b = input_file.read(readsize)
346
 
        if len(b) == 0:
347
 
            break
348
 
        yield b
 
228
    tofile.write(fromfile.read())
349
229
 
350
230
 
351
231
def sha_file(f):
445
325
    """Return size of given open file."""
446
326
    return os.fstat(f.fileno())[ST_SIZE]
447
327
 
448
 
 
449
328
# Define rand_bytes based on platform.
450
329
try:
451
330
    # Python 2.4 and later have os.urandom,
468
347
                n -= 1
469
348
            return s
470
349
 
471
 
 
472
 
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
473
 
def rand_chars(num):
474
 
    """Return a random string of num alphanumeric characters
475
 
    
476
 
    The result only contains lowercase chars because it may be used on 
477
 
    case-insensitive filesystems.
478
 
    """
479
 
    s = ''
480
 
    for raw_byte in rand_bytes(num):
481
 
        s += ALNUM[ord(raw_byte) % 36]
482
 
    return s
483
 
 
484
 
 
485
350
## TODO: We could later have path objects that remember their list
486
351
## decomposition (might be too tricksy though.)
487
352
 
522
387
    for f in p:
523
388
        if (f == '..') or (f == None) or (f == ''):
524
389
            raise BzrError("sorry, %r not allowed in path" % f)
525
 
    return pathjoin(*p)
 
390
    return os.path.join(*p)
526
391
 
527
392
 
528
393
def appendpath(p1, p2):
529
394
    if p1 == '':
530
395
        return p2
531
396
    else:
532
 
        return pathjoin(p1, p2)
 
397
        return os.path.join(p1, p2)
533
398
    
534
399
 
535
400
def split_lines(s):
536
401
    """Split s into lines, but without removing the newline characters."""
537
 
    lines = s.split('\n')
538
 
    result = [line + '\n' for line in lines[:-1]]
539
 
    if lines[-1]:
540
 
        result.append(lines[-1])
541
 
    return result
 
402
    return StringIO(s).readlines()
542
403
 
543
404
 
544
405
def hardlinks_good():
557
418
            raise
558
419
        copyfile(src, dest)
559
420
 
560
 
def delete_any(full_path):
561
 
    """Delete a file or directory."""
562
 
    try:
563
 
        os.unlink(full_path)
564
 
    except OSError, e:
565
 
    # We may be renaming a dangling inventory id
566
 
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
567
 
            raise
568
 
        os.rmdir(full_path)
569
 
 
570
421
 
571
422
def has_symlinks():
572
423
    if hasattr(os, 'symlink'):
601
452
 
602
453
    os.path.commonprefix (python2.4) has a bad bug that it works just
603
454
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
604
 
    avoids that problem.
605
 
    """
606
 
 
607
 
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
608
 
        ' exceed the platform minimum length (which is %d)' % 
609
 
        MIN_ABS_PATHLENGTH)
610
 
    rp = abspath(path)
 
455
    avoids that problem."""
 
456
    rp = os.path.abspath(path)
611
457
 
612
458
    s = []
613
459
    head = rp
620
466
    else:
621
467
        # XXX This should raise a NotChildPath exception, as its not tied
622
468
        # to branch anymore.
623
 
        raise PathNotChild(rp, base)
624
 
 
625
 
    if s:
626
 
        return pathjoin(*s)
627
 
    else:
628
 
        return ''
629
 
 
630
 
 
631
 
def safe_unicode(unicode_or_utf8_string):
632
 
    """Coerce unicode_or_utf8_string into unicode.
633
 
 
634
 
    If it is unicode, it is returned.
635
 
    Otherwise it is decoded from utf-8. If a decoding error
636
 
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
637
 
    as a BzrBadParameter exception.
638
 
    """
639
 
    if isinstance(unicode_or_utf8_string, unicode):
640
 
        return unicode_or_utf8_string
641
 
    try:
642
 
        return unicode_or_utf8_string.decode('utf8')
643
 
    except UnicodeDecodeError:
644
 
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
645
 
 
646
 
 
647
 
def terminal_width():
648
 
    """Return estimated terminal width."""
649
 
 
650
 
    # TODO: Do something smart on Windows?
651
 
 
652
 
    # TODO: Is there anything that gets a better update when the window
653
 
    # is resized while the program is running? We could use the Python termcap
654
 
    # library.
655
 
    try:
656
 
        return int(os.environ['COLUMNS'])
657
 
    except (IndexError, KeyError, ValueError):
658
 
        return 80
659
 
 
660
 
def supports_executable():
661
 
    return sys.platform != "win32"
662
 
 
663
 
 
664
 
def strip_trailing_slash(path):
665
 
    """Strip trailing slash, except for root paths.
666
 
    The definition of 'root path' is platform-dependent.
667
 
    """
668
 
    if len(path) != MIN_ABS_PATHLENGTH and path[-1] == '/':
669
 
        return path[:-1]
670
 
    else:
671
 
        return path
672
 
 
673
 
 
674
 
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
675
 
 
676
 
 
677
 
def check_legal_path(path):
678
 
    """Check whether the supplied path is legal.  
679
 
    This is only required on Windows, so we don't test on other platforms
680
 
    right now.
681
 
    """
682
 
    if sys.platform != "win32":
683
 
        return
684
 
    if _validWin32PathRE.match(path) is None:
685
 
        raise IllegalPath(path)
 
469
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
470
 
 
471
    return os.sep.join(s)