/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Whitespace cleanups.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
 
1
# Bazaar-NG -- distributed version control
 
2
#
 
3
# Copyright (C) 2005 by Canonical Ltd
 
4
#
 
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.
 
9
#
 
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.
 
14
#
 
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
 
18
 
 
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
 
23
import errno
 
24
import os
 
25
import re
 
26
import sha
 
27
import string
 
28
import sys
 
29
import time
 
30
import types
 
31
import tempfile
 
32
 
 
33
import bzrlib
 
34
from bzrlib.errors import BzrError, PathNotChild, NoSuchFile
 
35
from bzrlib.trace import mutter
 
36
 
 
37
 
 
38
def make_readonly(filename):
 
39
    """Make a filename read-only."""
 
40
    mod = os.stat(filename).st_mode
 
41
    mod = mod & 0777555
 
42
    os.chmod(filename, mod)
 
43
 
 
44
 
 
45
def make_writable(filename):
 
46
    mod = os.stat(filename).st_mode
 
47
    mod = mod | 0200
 
48
    os.chmod(filename, mod)
 
49
 
 
50
 
 
51
_QUOTE_RE = None
 
52
 
 
53
 
 
54
def quotefn(f):
 
55
    """Return a quoted filename filename
 
56
 
 
57
    This previously used backslash quoting, but that works poorly on
 
58
    Windows."""
 
59
    # TODO: I'm not really sure this is the best format either.x
 
60
    global _QUOTE_RE
 
61
    if _QUOTE_RE == None:
 
62
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
63
        
 
64
    if _QUOTE_RE.search(f):
 
65
        return '"' + f + '"'
 
66
    else:
 
67
        return f
 
68
 
 
69
 
 
70
def file_kind(f):
 
71
    mode = os.lstat(f)[ST_MODE]
 
72
    if S_ISREG(mode):
 
73
        return 'file'
 
74
    elif S_ISDIR(mode):
 
75
        return 'directory'
 
76
    elif S_ISLNK(mode):
 
77
        return 'symlink'
 
78
    elif S_ISCHR(mode):
 
79
        return 'chardev'
 
80
    elif S_ISBLK(mode):
 
81
        return 'block'
 
82
    elif S_ISFIFO(mode):
 
83
        return 'fifo'
 
84
    elif S_ISSOCK(mode):
 
85
        return 'socket'
 
86
    else:
 
87
        return 'unknown'
 
88
 
 
89
 
 
90
def kind_marker(kind):
 
91
    if kind == 'file':
 
92
        return ''
 
93
    elif kind == 'directory':
 
94
        return '/'
 
95
    elif kind == 'symlink':
 
96
        return '@'
 
97
    else:
 
98
        raise BzrError('invalid file kind %r' % kind)
 
99
 
 
100
def lexists(f):
 
101
    if hasattr(os.path, 'lexists'):
 
102
        return os.path.lexists(f)
 
103
    try:
 
104
        if hasattr(os, 'lstat'):
 
105
            os.lstat(f)
 
106
        else:
 
107
            os.stat(f)
 
108
        return True
 
109
    except OSError,e:
 
110
        if e.errno == errno.ENOENT:
 
111
            return False;
 
112
        else:
 
113
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
114
 
 
115
def fancy_rename(old, new, rename_func, unlink_func):
 
116
    """A fancy rename, when you don't have atomic rename.
 
117
    
 
118
    :param old: The old path, to rename from
 
119
    :param new: The new path, to rename to
 
120
    :param rename_func: The potentially non-atomic rename function
 
121
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
122
    """
 
123
 
 
124
    # sftp rename doesn't allow overwriting, so play tricks:
 
125
    import random
 
126
    base = os.path.basename(new)
 
127
    dirname = os.path.dirname(new)
 
128
    tmp_name = u'tmp.%s.%.9f.%d.%d' % (base, time.time(), os.getpid(), random.randint(0, 0x7FFFFFFF))
 
129
    tmp_name = pathjoin(dirname, tmp_name)
 
130
 
 
131
    # Rename the file out of the way, but keep track if it didn't exist
 
132
    # We don't want to grab just any exception
 
133
    # something like EACCES should prevent us from continuing
 
134
    # The downside is that the rename_func has to throw an exception
 
135
    # with an errno = ENOENT, or NoSuchFile
 
136
    file_existed = False
 
137
    try:
 
138
        rename_func(new, tmp_name)
 
139
    except (NoSuchFile,), e:
 
140
        pass
 
141
    except Exception, e:
 
142
        if (not hasattr(e, 'errno') 
 
143
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
144
            raise
 
145
    else:
 
146
        file_existed = True
 
147
 
 
148
    success = False
 
149
    try:
 
150
        # This may throw an exception, in which case success will
 
151
        # not be set.
 
152
        rename_func(old, new)
 
153
        success = True
 
154
    finally:
 
155
        if file_existed:
 
156
            # If the file used to exist, rename it back into place
 
157
            # otherwise just delete it from the tmp location
 
158
            if success:
 
159
                unlink_func(tmp_name)
 
160
            else:
 
161
                rename_func(tmp_name, new)
 
162
 
 
163
# Default is to just use the python builtins
 
164
abspath = os.path.abspath
 
165
realpath = os.path.realpath
 
166
pathjoin = os.path.join
 
167
normpath = os.path.normpath
 
168
getcwd = os.getcwdu
 
169
mkdtemp = tempfile.mkdtemp
 
170
rename = os.rename
 
171
dirname = os.path.dirname
 
172
basename = os.path.basename
 
173
 
 
174
if os.name == "posix":
 
175
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
176
    # choke on a Unicode string containing a relative path if
 
177
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
178
    # string.
 
179
    _fs_enc = sys.getfilesystemencoding()
 
180
    def abspath(path):
 
181
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
182
 
 
183
    def realpath(path):
 
184
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
185
 
 
186
if sys.platform == 'win32':
 
187
    # We need to use the Unicode-aware os.path.abspath and
 
188
    # os.path.realpath on Windows systems.
 
189
    def abspath(path):
 
190
        return os.path.abspath(path).replace('\\', '/')
 
191
 
 
192
    def realpath(path):
 
193
        return os.path.realpath(path).replace('\\', '/')
 
194
 
 
195
    def pathjoin(*args):
 
196
        return os.path.join(*args).replace('\\', '/')
 
197
 
 
198
    def normpath(path):
 
199
        return os.path.normpath(path).replace('\\', '/')
 
200
 
 
201
    def getcwd():
 
202
        return os.getcwdu().replace('\\', '/')
 
203
 
 
204
    def mkdtemp(*args, **kwargs):
 
205
        return tempfile.mkdtemp(*args, **kwargs).replace('\\', '/')
 
206
 
 
207
    def rename(old, new):
 
208
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
209
 
 
210
def normalizepath(f):
 
211
    if hasattr(os.path, 'realpath'):
 
212
        F = realpath
 
213
    else:
 
214
        F = abspath
 
215
    [p,e] = os.path.split(f)
 
216
    if e == "" or e == "." or e == "..":
 
217
        return F(f)
 
218
    else:
 
219
        return pathjoin(F(p), e)
 
220
 
 
221
 
 
222
def backup_file(fn):
 
223
    """Copy a file to a backup.
 
224
 
 
225
    Backups are named in GNU-style, with a ~ suffix.
 
226
 
 
227
    If the file is already a backup, it's not copied.
 
228
    """
 
229
    if fn[-1] == '~':
 
230
        return
 
231
    bfn = fn + '~'
 
232
 
 
233
    if has_symlinks() and os.path.islink(fn):
 
234
        target = os.readlink(fn)
 
235
        os.symlink(target, bfn)
 
236
        return
 
237
    inf = file(fn, 'rb')
 
238
    try:
 
239
        content = inf.read()
 
240
    finally:
 
241
        inf.close()
 
242
    
 
243
    outf = file(bfn, 'wb')
 
244
    try:
 
245
        outf.write(content)
 
246
    finally:
 
247
        outf.close()
 
248
 
 
249
 
 
250
def isdir(f):
 
251
    """True if f is an accessible directory."""
 
252
    try:
 
253
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
254
    except OSError:
 
255
        return False
 
256
 
 
257
 
 
258
def isfile(f):
 
259
    """True if f is a regular file."""
 
260
    try:
 
261
        return S_ISREG(os.lstat(f)[ST_MODE])
 
262
    except OSError:
 
263
        return False
 
264
 
 
265
def islink(f):
 
266
    """True if f is a symlink."""
 
267
    try:
 
268
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
269
    except OSError:
 
270
        return False
 
271
 
 
272
def is_inside(dir, fname):
 
273
    """True if fname is inside dir.
 
274
    
 
275
    The parameters should typically be passed to osutils.normpath first, so
 
276
    that . and .. and repeated slashes are eliminated, and the separators
 
277
    are canonical for the platform.
 
278
    
 
279
    The empty string as a dir name is taken as top-of-tree and matches 
 
280
    everything.
 
281
    
 
282
    >>> is_inside('src', pathjoin('src', 'foo.c'))
 
283
    True
 
284
    >>> is_inside('src', 'srccontrol')
 
285
    False
 
286
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
 
287
    True
 
288
    >>> is_inside('foo.c', 'foo.c')
 
289
    True
 
290
    >>> is_inside('foo.c', '')
 
291
    False
 
292
    >>> is_inside('', 'foo.c')
 
293
    True
 
294
    """
 
295
    # XXX: Most callers of this can actually do something smarter by 
 
296
    # looking at the inventory
 
297
    if dir == fname:
 
298
        return True
 
299
    
 
300
    if dir == '':
 
301
        return True
 
302
 
 
303
    if dir[-1] != '/':
 
304
        dir += '/'
 
305
 
 
306
    return fname.startswith(dir)
 
307
 
 
308
 
 
309
def is_inside_any(dir_list, fname):
 
310
    """True if fname is inside any of given dirs."""
 
311
    for dirname in dir_list:
 
312
        if is_inside(dirname, fname):
 
313
            return True
 
314
    else:
 
315
        return False
 
316
 
 
317
 
 
318
def pumpfile(fromfile, tofile):
 
319
    """Copy contents of one file to another."""
 
320
    BUFSIZE = 32768
 
321
    while True:
 
322
        b = fromfile.read(BUFSIZE)
 
323
        if not b:
 
324
            break
 
325
        tofile.write(b)
 
326
 
 
327
 
 
328
def sha_file(f):
 
329
    if hasattr(f, 'tell'):
 
330
        assert f.tell() == 0
 
331
    s = sha.new()
 
332
    BUFSIZE = 128<<10
 
333
    while True:
 
334
        b = f.read(BUFSIZE)
 
335
        if not b:
 
336
            break
 
337
        s.update(b)
 
338
    return s.hexdigest()
 
339
 
 
340
 
 
341
 
 
342
def sha_strings(strings):
 
343
    """Return the sha-1 of concatenation of strings"""
 
344
    s = sha.new()
 
345
    map(s.update, strings)
 
346
    return s.hexdigest()
 
347
 
 
348
 
 
349
def sha_string(f):
 
350
    s = sha.new()
 
351
    s.update(f)
 
352
    return s.hexdigest()
 
353
 
 
354
 
 
355
def fingerprint_file(f):
 
356
    s = sha.new()
 
357
    b = f.read()
 
358
    s.update(b)
 
359
    size = len(b)
 
360
    return {'size': size,
 
361
            'sha1': s.hexdigest()}
 
362
 
 
363
 
 
364
def compare_files(a, b):
 
365
    """Returns true if equal in contents"""
 
366
    BUFSIZE = 4096
 
367
    while True:
 
368
        ai = a.read(BUFSIZE)
 
369
        bi = b.read(BUFSIZE)
 
370
        if ai != bi:
 
371
            return False
 
372
        if ai == '':
 
373
            return True
 
374
 
 
375
 
 
376
def local_time_offset(t=None):
 
377
    """Return offset of local zone from GMT, either at present or at time t."""
 
378
    # python2.3 localtime() can't take None
 
379
    if t == None:
 
380
        t = time.time()
 
381
        
 
382
    if time.localtime(t).tm_isdst and time.daylight:
 
383
        return -time.altzone
 
384
    else:
 
385
        return -time.timezone
 
386
 
 
387
    
 
388
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
389
                show_offset=True):
 
390
    ## TODO: Perhaps a global option to use either universal or local time?
 
391
    ## Or perhaps just let people set $TZ?
 
392
    assert isinstance(t, float)
 
393
    
 
394
    if timezone == 'utc':
 
395
        tt = time.gmtime(t)
 
396
        offset = 0
 
397
    elif timezone == 'original':
 
398
        if offset == None:
 
399
            offset = 0
 
400
        tt = time.gmtime(t + offset)
 
401
    elif timezone == 'local':
 
402
        tt = time.localtime(t)
 
403
        offset = local_time_offset(t)
 
404
    else:
 
405
        raise BzrError("unsupported timezone format %r" % timezone,
 
406
                       ['options are "utc", "original", "local"'])
 
407
    if date_fmt is None:
 
408
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
409
    if show_offset:
 
410
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
411
    else:
 
412
        offset_str = ''
 
413
    return (time.strftime(date_fmt, tt) +  offset_str)
 
414
 
 
415
 
 
416
def compact_date(when):
 
417
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
 
418
    
 
419
 
 
420
 
 
421
def filesize(f):
 
422
    """Return size of given open file."""
 
423
    return os.fstat(f.fileno())[ST_SIZE]
 
424
 
 
425
# Define rand_bytes based on platform.
 
426
try:
 
427
    # Python 2.4 and later have os.urandom,
 
428
    # but it doesn't work on some arches
 
429
    os.urandom(1)
 
430
    rand_bytes = os.urandom
 
431
except (NotImplementedError, AttributeError):
 
432
    # If python doesn't have os.urandom, or it doesn't work,
 
433
    # then try to first pull random data from /dev/urandom
 
434
    if os.path.exists("/dev/urandom"):
 
435
        rand_bytes = file('/dev/urandom', 'rb').read
 
436
    # Otherwise, use this hack as a last resort
 
437
    else:
 
438
        # not well seeded, but better than nothing
 
439
        def rand_bytes(n):
 
440
            import random
 
441
            s = ''
 
442
            while n:
 
443
                s += chr(random.randint(0, 255))
 
444
                n -= 1
 
445
            return s
 
446
 
 
447
## TODO: We could later have path objects that remember their list
 
448
## decomposition (might be too tricksy though.)
 
449
 
 
450
def splitpath(p):
 
451
    """Turn string into list of parts.
 
452
 
 
453
    >>> splitpath('a')
 
454
    ['a']
 
455
    >>> splitpath('a/b')
 
456
    ['a', 'b']
 
457
    >>> splitpath('a/./b')
 
458
    ['a', 'b']
 
459
    >>> splitpath('a/.b')
 
460
    ['a', '.b']
 
461
    >>> splitpath('a/../b')
 
462
    Traceback (most recent call last):
 
463
    ...
 
464
    BzrError: sorry, '..' not allowed in path
 
465
    """
 
466
    assert isinstance(p, types.StringTypes)
 
467
 
 
468
    # split on either delimiter because people might use either on
 
469
    # Windows
 
470
    ps = re.split(r'[\\/]', p)
 
471
 
 
472
    rps = []
 
473
    for f in ps:
 
474
        if f == '..':
 
475
            raise BzrError("sorry, %r not allowed in path" % f)
 
476
        elif (f == '.') or (f == ''):
 
477
            pass
 
478
        else:
 
479
            rps.append(f)
 
480
    return rps
 
481
 
 
482
def joinpath(p):
 
483
    assert isinstance(p, list)
 
484
    for f in p:
 
485
        if (f == '..') or (f == None) or (f == ''):
 
486
            raise BzrError("sorry, %r not allowed in path" % f)
 
487
    return pathjoin(*p)
 
488
 
 
489
 
 
490
def appendpath(p1, p2):
 
491
    if p1 == '':
 
492
        return p2
 
493
    else:
 
494
        return pathjoin(p1, p2)
 
495
    
 
496
 
 
497
def split_lines(s):
 
498
    """Split s into lines, but without removing the newline characters."""
 
499
    return StringIO(s).readlines()
 
500
 
 
501
 
 
502
def hardlinks_good():
 
503
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
504
 
 
505
 
 
506
def link_or_copy(src, dest):
 
507
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
508
    if not hardlinks_good():
 
509
        copyfile(src, dest)
 
510
        return
 
511
    try:
 
512
        os.link(src, dest)
 
513
    except (OSError, IOError), e:
 
514
        if e.errno != errno.EXDEV:
 
515
            raise
 
516
        copyfile(src, dest)
 
517
 
 
518
 
 
519
def has_symlinks():
 
520
    if hasattr(os, 'symlink'):
 
521
        return True
 
522
    else:
 
523
        return False
 
524
        
 
525
 
 
526
def contains_whitespace(s):
 
527
    """True if there are any whitespace characters in s."""
 
528
    for ch in string.whitespace:
 
529
        if ch in s:
 
530
            return True
 
531
    else:
 
532
        return False
 
533
 
 
534
 
 
535
def contains_linebreaks(s):
 
536
    """True if there is any vertical whitespace in s."""
 
537
    for ch in '\f\n\r':
 
538
        if ch in s:
 
539
            return True
 
540
    else:
 
541
        return False
 
542
 
 
543
 
 
544
def relpath(base, path):
 
545
    """Return path relative to base, or raise exception.
 
546
 
 
547
    The path may be either an absolute path or a path relative to the
 
548
    current working directory.
 
549
 
 
550
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
551
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
552
    avoids that problem."""
 
553
    rp = abspath(path)
 
554
 
 
555
    s = []
 
556
    head = rp
 
557
    while len(head) >= len(base):
 
558
        if head == base:
 
559
            break
 
560
        head, tail = os.path.split(head)
 
561
        if tail:
 
562
            s.insert(0, tail)
 
563
    else:
 
564
        # XXX This should raise a NotChildPath exception, as its not tied
 
565
        # to branch anymore.
 
566
        raise PathNotChild(rp, base)
 
567
 
 
568
    if s:
 
569
        return pathjoin(*s)
 
570
    else:
 
571
        return ''
 
572
 
 
573
 
 
574
def terminal_width():
 
575
    """Return estimated terminal width."""
 
576
 
 
577
    # TODO: Do something smart on Windows?
 
578
 
 
579
    # TODO: Is there anything that gets a better update when the window
 
580
    # is resized while the program is running? We could use the Python termcap
 
581
    # library.
 
582
    try:
 
583
        return int(os.environ['COLUMNS'])
 
584
    except (IndexError, KeyError, ValueError):
 
585
        return 80