~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2006-01-13 08:12:22 UTC
  • mfrom: (1185.63.5 bzr.patches)
  • Revision ID: mbp@sourcefrog.net-20060113081222-6b572004a2ade0cc
[merge] test_hashcache_raise from Denys

Show diffs side-by-side

added added

removed removed

Lines of Context:
28
28
import sys
29
29
import time
30
30
import types
 
31
import tempfile
31
32
 
32
33
import bzrlib
33
 
from bzrlib.config import config_dir, _get_user_id
34
 
from bzrlib.errors import BzrError
 
34
from bzrlib.errors import (BzrError,
 
35
                           BzrBadParameter,
 
36
                           NoSuchFile,
 
37
                           PathNotChild,
 
38
                           )
35
39
from bzrlib.trace import mutter
36
40
 
37
41
 
98
102
        raise BzrError('invalid file kind %r' % kind)
99
103
 
100
104
def lexists(f):
 
105
    if hasattr(os.path, 'lexists'):
 
106
        return os.path.lexists(f)
101
107
    try:
102
108
        if hasattr(os, 'lstat'):
103
109
            os.lstat(f)
110
116
        else:
111
117
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
112
118
 
 
119
def fancy_rename(old, new, rename_func, unlink_func):
 
120
    """A fancy rename, when you don't have atomic rename.
 
121
    
 
122
    :param old: The old path, to rename from
 
123
    :param new: The new path, to rename to
 
124
    :param rename_func: The potentially non-atomic rename function
 
125
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
126
    """
 
127
 
 
128
    # sftp rename doesn't allow overwriting, so play tricks:
 
129
    import random
 
130
    base = os.path.basename(new)
 
131
    dirname = os.path.dirname(new)
 
132
    tmp_name = u'tmp.%s.%.9f.%d.%d' % (base, time.time(), os.getpid(), random.randint(0, 0x7FFFFFFF))
 
133
    tmp_name = pathjoin(dirname, tmp_name)
 
134
 
 
135
    # Rename the file out of the way, but keep track if it didn't exist
 
136
    # We don't want to grab just any exception
 
137
    # something like EACCES should prevent us from continuing
 
138
    # The downside is that the rename_func has to throw an exception
 
139
    # with an errno = ENOENT, or NoSuchFile
 
140
    file_existed = False
 
141
    try:
 
142
        rename_func(new, tmp_name)
 
143
    except (NoSuchFile,), e:
 
144
        pass
 
145
    except IOError, e:
 
146
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
 
147
        # function raises an IOError with errno == None when a rename fails.
 
148
        # This then gets caught here.
 
149
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
 
150
            raise
 
151
    except Exception, e:
 
152
        if (not hasattr(e, 'errno') 
 
153
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
154
            raise
 
155
    else:
 
156
        file_existed = True
 
157
 
 
158
    success = False
 
159
    try:
 
160
        # This may throw an exception, in which case success will
 
161
        # not be set.
 
162
        rename_func(old, new)
 
163
        success = True
 
164
    finally:
 
165
        if file_existed:
 
166
            # If the file used to exist, rename it back into place
 
167
            # otherwise just delete it from the tmp location
 
168
            if success:
 
169
                unlink_func(tmp_name)
 
170
            else:
 
171
                rename_func(tmp_name, new)
 
172
 
 
173
# Default is to just use the python builtins
 
174
abspath = os.path.abspath
 
175
realpath = os.path.realpath
 
176
pathjoin = os.path.join
 
177
normpath = os.path.normpath
 
178
getcwd = os.getcwdu
 
179
mkdtemp = tempfile.mkdtemp
 
180
rename = os.rename
 
181
dirname = os.path.dirname
 
182
basename = os.path.basename
 
183
 
 
184
if os.name == "posix":
 
185
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
186
    # choke on a Unicode string containing a relative path if
 
187
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
188
    # string.
 
189
    _fs_enc = sys.getfilesystemencoding()
 
190
    def abspath(path):
 
191
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
192
 
 
193
    def realpath(path):
 
194
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
195
 
 
196
if sys.platform == 'win32':
 
197
    # We need to use the Unicode-aware os.path.abspath and
 
198
    # os.path.realpath on Windows systems.
 
199
    def abspath(path):
 
200
        return os.path.abspath(path).replace('\\', '/')
 
201
 
 
202
    def realpath(path):
 
203
        return os.path.realpath(path).replace('\\', '/')
 
204
 
 
205
    def pathjoin(*args):
 
206
        return os.path.join(*args).replace('\\', '/')
 
207
 
 
208
    def normpath(path):
 
209
        return os.path.normpath(path).replace('\\', '/')
 
210
 
 
211
    def getcwd():
 
212
        return os.getcwdu().replace('\\', '/')
 
213
 
 
214
    def mkdtemp(*args, **kwargs):
 
215
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
216
 
 
217
    def rename(old, new):
 
218
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
219
 
 
220
 
113
221
def normalizepath(f):
114
222
    if hasattr(os.path, 'realpath'):
115
 
        F = os.path.realpath
 
223
        F = realpath
116
224
    else:
117
 
        F = os.path.abspath
 
225
        F = abspath
118
226
    [p,e] = os.path.split(f)
119
227
    if e == "" or e == "." or e == "..":
120
228
        return F(f)
121
229
    else:
122
 
        return os.path.join(F(p), e)
123
 
    
 
230
        return pathjoin(F(p), e)
 
231
 
124
232
 
125
233
def backup_file(fn):
126
234
    """Copy a file to a backup.
149
257
    finally:
150
258
        outf.close()
151
259
 
152
 
if os.name == 'nt':
153
 
    import shutil
154
 
    rename = shutil.move
155
 
else:
156
 
    rename = os.rename
157
 
 
158
260
 
159
261
def isdir(f):
160
262
    """True if f is an accessible directory."""
181
283
def is_inside(dir, fname):
182
284
    """True if fname is inside dir.
183
285
    
184
 
    The parameters should typically be passed to os.path.normpath first, so
 
286
    The parameters should typically be passed to osutils.normpath first, so
185
287
    that . and .. and repeated slashes are eliminated, and the separators
186
288
    are canonical for the platform.
187
289
    
188
290
    The empty string as a dir name is taken as top-of-tree and matches 
189
291
    everything.
190
292
    
191
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
293
    >>> is_inside('src', pathjoin('src', 'foo.c'))
192
294
    True
193
295
    >>> is_inside('src', 'srccontrol')
194
296
    False
195
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
297
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
196
298
    True
197
299
    >>> is_inside('foo.c', 'foo.c')
198
300
    True
209
311
    if dir == '':
210
312
        return True
211
313
 
212
 
    if dir[-1] != os.sep:
213
 
        dir += os.sep
 
314
    if dir[-1] != '/':
 
315
        dir += '/'
214
316
 
215
317
    return fname.startswith(dir)
216
318
 
226
328
 
227
329
def pumpfile(fromfile, tofile):
228
330
    """Copy contents of one file to another."""
229
 
    tofile.write(fromfile.read())
 
331
    BUFSIZE = 32768
 
332
    while True:
 
333
        b = fromfile.read(BUFSIZE)
 
334
        if not b:
 
335
            break
 
336
        tofile.write(b)
230
337
 
231
338
 
232
339
def sha_file(f):
289
396
        return -time.timezone
290
397
 
291
398
    
292
 
def format_date(t, offset=0, timezone='original'):
 
399
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
400
                show_offset=True):
293
401
    ## TODO: Perhaps a global option to use either universal or local time?
294
402
    ## Or perhaps just let people set $TZ?
295
403
    assert isinstance(t, float)
307
415
    else:
308
416
        raise BzrError("unsupported timezone format %r" % timezone,
309
417
                       ['options are "utc", "original", "local"'])
310
 
 
311
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
312
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
418
    if date_fmt is None:
 
419
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
420
    if show_offset:
 
421
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
422
    else:
 
423
        offset_str = ''
 
424
    return (time.strftime(date_fmt, tt) +  offset_str)
313
425
 
314
426
 
315
427
def compact_date(when):
383
495
    for f in p:
384
496
        if (f == '..') or (f == None) or (f == ''):
385
497
            raise BzrError("sorry, %r not allowed in path" % f)
386
 
    return os.path.join(*p)
 
498
    return pathjoin(*p)
387
499
 
388
500
 
389
501
def appendpath(p1, p2):
390
502
    if p1 == '':
391
503
        return p2
392
504
    else:
393
 
        return os.path.join(p1, p2)
 
505
        return pathjoin(p1, p2)
394
506
    
395
507
 
396
508
def split_lines(s):
438
550
            return True
439
551
    else:
440
552
        return False
 
553
 
 
554
 
 
555
def relpath(base, path):
 
556
    """Return path relative to base, or raise exception.
 
557
 
 
558
    The path may be either an absolute path or a path relative to the
 
559
    current working directory.
 
560
 
 
561
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
562
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
563
    avoids that problem."""
 
564
    rp = abspath(path)
 
565
 
 
566
    s = []
 
567
    head = rp
 
568
    while len(head) >= len(base):
 
569
        if head == base:
 
570
            break
 
571
        head, tail = os.path.split(head)
 
572
        if tail:
 
573
            s.insert(0, tail)
 
574
    else:
 
575
        # XXX This should raise a NotChildPath exception, as its not tied
 
576
        # to branch anymore.
 
577
        raise PathNotChild(rp, base)
 
578
 
 
579
    if s:
 
580
        return pathjoin(*s)
 
581
    else:
 
582
        return ''
 
583
 
 
584
 
 
585
def safe_unicode(unicode_or_utf8_string):
 
586
    """Coerce unicode_or_utf8_string into unicode.
 
587
 
 
588
    If it is unicode, it is returned.
 
589
    Otherwise it is decoded from utf-8. If a decoding error
 
590
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
591
    as a BzrBadParameter exception.
 
592
    """
 
593
    if isinstance(unicode_or_utf8_string, unicode):
 
594
        return unicode_or_utf8_string
 
595
    try:
 
596
        return unicode_or_utf8_string.decode('utf8')
 
597
    except UnicodeDecodeError:
 
598
        raise BzrBadParameter(unicode_or_utf8_string)
 
599
 
 
600
 
 
601
def terminal_width():
 
602
    """Return estimated terminal width."""
 
603
 
 
604
    # TODO: Do something smart on Windows?
 
605
 
 
606
    # TODO: Is there anything that gets a better update when the window
 
607
    # is resized while the program is running? We could use the Python termcap
 
608
    # library.
 
609
    try:
 
610
        return int(os.environ['COLUMNS'])
 
611
    except (IndexError, KeyError, ValueError):
 
612
        return 80