/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

  • Committer: Aaron Bentley
  • Date: 2005-10-18 18:48:27 UTC
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1474.
  • Revision ID: abentley@panoramicfeedback.com-20051018184827-2cc69376beb1cdf3
Switched to ConfigObj

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
 
 
32
import bzrlib
 
33
from bzrlib.errors import BzrError, NotBranchError
 
34
from bzrlib.trace import mutter
 
35
 
 
36
 
 
37
def make_readonly(filename):
 
38
    """Make a filename read-only."""
 
39
    mod = os.stat(filename).st_mode
 
40
    mod = mod & 0777555
 
41
    os.chmod(filename, mod)
 
42
 
 
43
 
 
44
def make_writable(filename):
 
45
    mod = os.stat(filename).st_mode
 
46
    mod = mod | 0200
 
47
    os.chmod(filename, mod)
 
48
 
 
49
 
 
50
_QUOTE_RE = None
 
51
 
 
52
 
 
53
def quotefn(f):
 
54
    """Return a quoted filename filename
 
55
 
 
56
    This previously used backslash quoting, but that works poorly on
 
57
    Windows."""
 
58
    # TODO: I'm not really sure this is the best format either.x
 
59
    global _QUOTE_RE
 
60
    if _QUOTE_RE == None:
 
61
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
62
        
 
63
    if _QUOTE_RE.search(f):
 
64
        return '"' + f + '"'
 
65
    else:
 
66
        return f
 
67
 
 
68
 
 
69
def file_kind(f):
 
70
    mode = os.lstat(f)[ST_MODE]
 
71
    if S_ISREG(mode):
 
72
        return 'file'
 
73
    elif S_ISDIR(mode):
 
74
        return 'directory'
 
75
    elif S_ISLNK(mode):
 
76
        return 'symlink'
 
77
    elif S_ISCHR(mode):
 
78
        return 'chardev'
 
79
    elif S_ISBLK(mode):
 
80
        return 'block'
 
81
    elif S_ISFIFO(mode):
 
82
        return 'fifo'
 
83
    elif S_ISSOCK(mode):
 
84
        return 'socket'
 
85
    else:
 
86
        return 'unknown'
 
87
 
 
88
 
 
89
def kind_marker(kind):
 
90
    if kind == 'file':
 
91
        return ''
 
92
    elif kind == 'directory':
 
93
        return '/'
 
94
    elif kind == 'symlink':
 
95
        return '@'
 
96
    else:
 
97
        raise BzrError('invalid file kind %r' % kind)
 
98
 
 
99
def lexists(f):
 
100
    try:
 
101
        if hasattr(os, 'lstat'):
 
102
            os.lstat(f)
 
103
        else:
 
104
            os.stat(f)
 
105
        return True
 
106
    except OSError,e:
 
107
        if e.errno == errno.ENOENT:
 
108
            return False;
 
109
        else:
 
110
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
111
 
 
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)
 
122
    
 
123
 
 
124
def backup_file(fn):
 
125
    """Copy a file to a backup.
 
126
 
 
127
    Backups are named in GNU-style, with a ~ suffix.
 
128
 
 
129
    If the file is already a backup, it's not copied.
 
130
    """
 
131
    if fn[-1] == '~':
 
132
        return
 
133
    bfn = fn + '~'
 
134
 
 
135
    if has_symlinks() and os.path.islink(fn):
 
136
        target = os.readlink(fn)
 
137
        os.symlink(target, bfn)
 
138
        return
 
139
    inf = file(fn, 'rb')
 
140
    try:
 
141
        content = inf.read()
 
142
    finally:
 
143
        inf.close()
 
144
    
 
145
    outf = file(bfn, 'wb')
 
146
    try:
 
147
        outf.write(content)
 
148
    finally:
 
149
        outf.close()
 
150
 
 
151
if os.name == 'nt':
 
152
    import shutil
 
153
    rename = shutil.move
 
154
else:
 
155
    rename = os.rename
 
156
 
 
157
 
 
158
def isdir(f):
 
159
    """True if f is an accessible directory."""
 
160
    try:
 
161
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
162
    except OSError:
 
163
        return False
 
164
 
 
165
 
 
166
def isfile(f):
 
167
    """True if f is a regular file."""
 
168
    try:
 
169
        return S_ISREG(os.lstat(f)[ST_MODE])
 
170
    except OSError:
 
171
        return False
 
172
 
 
173
def islink(f):
 
174
    """True if f is a symlink."""
 
175
    try:
 
176
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
177
    except OSError:
 
178
        return False
 
179
 
 
180
def is_inside(dir, fname):
 
181
    """True if fname is inside dir.
 
182
    
 
183
    The parameters should typically be passed to os.path.normpath first, so
 
184
    that . and .. and repeated slashes are eliminated, and the separators
 
185
    are canonical for the platform.
 
186
    
 
187
    The empty string as a dir name is taken as top-of-tree and matches 
 
188
    everything.
 
189
    
 
190
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
191
    True
 
192
    >>> is_inside('src', 'srccontrol')
 
193
    False
 
194
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
195
    True
 
196
    >>> is_inside('foo.c', 'foo.c')
 
197
    True
 
198
    >>> is_inside('foo.c', '')
 
199
    False
 
200
    >>> is_inside('', 'foo.c')
 
201
    True
 
202
    """
 
203
    # XXX: Most callers of this can actually do something smarter by 
 
204
    # looking at the inventory
 
205
    if dir == fname:
 
206
        return True
 
207
    
 
208
    if dir == '':
 
209
        return True
 
210
 
 
211
    if dir[-1] != os.sep:
 
212
        dir += os.sep
 
213
 
 
214
    return fname.startswith(dir)
 
215
 
 
216
 
 
217
def is_inside_any(dir_list, fname):
 
218
    """True if fname is inside any of given dirs."""
 
219
    for dirname in dir_list:
 
220
        if is_inside(dirname, fname):
 
221
            return True
 
222
    else:
 
223
        return False
 
224
 
 
225
 
 
226
def pumpfile(fromfile, tofile):
 
227
    """Copy contents of one file to another."""
 
228
    tofile.write(fromfile.read())
 
229
 
 
230
 
 
231
def sha_file(f):
 
232
    if hasattr(f, 'tell'):
 
233
        assert f.tell() == 0
 
234
    s = sha.new()
 
235
    BUFSIZE = 128<<10
 
236
    while True:
 
237
        b = f.read(BUFSIZE)
 
238
        if not b:
 
239
            break
 
240
        s.update(b)
 
241
    return s.hexdigest()
 
242
 
 
243
 
 
244
 
 
245
def sha_strings(strings):
 
246
    """Return the sha-1 of concatenation of strings"""
 
247
    s = sha.new()
 
248
    map(s.update, strings)
 
249
    return s.hexdigest()
 
250
 
 
251
 
 
252
def sha_string(f):
 
253
    s = sha.new()
 
254
    s.update(f)
 
255
    return s.hexdigest()
 
256
 
 
257
 
 
258
def fingerprint_file(f):
 
259
    s = sha.new()
 
260
    b = f.read()
 
261
    s.update(b)
 
262
    size = len(b)
 
263
    return {'size': size,
 
264
            'sha1': s.hexdigest()}
 
265
 
 
266
 
 
267
def compare_files(a, b):
 
268
    """Returns true if equal in contents"""
 
269
    BUFSIZE = 4096
 
270
    while True:
 
271
        ai = a.read(BUFSIZE)
 
272
        bi = b.read(BUFSIZE)
 
273
        if ai != bi:
 
274
            return False
 
275
        if ai == '':
 
276
            return True
 
277
 
 
278
 
 
279
def local_time_offset(t=None):
 
280
    """Return offset of local zone from GMT, either at present or at time t."""
 
281
    # python2.3 localtime() can't take None
 
282
    if t == None:
 
283
        t = time.time()
 
284
        
 
285
    if time.localtime(t).tm_isdst and time.daylight:
 
286
        return -time.altzone
 
287
    else:
 
288
        return -time.timezone
 
289
 
 
290
    
 
291
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
292
                show_offset=True):
 
293
    ## TODO: Perhaps a global option to use either universal or local time?
 
294
    ## Or perhaps just let people set $TZ?
 
295
    assert isinstance(t, float)
 
296
    
 
297
    if timezone == 'utc':
 
298
        tt = time.gmtime(t)
 
299
        offset = 0
 
300
    elif timezone == 'original':
 
301
        if offset == None:
 
302
            offset = 0
 
303
        tt = time.gmtime(t + offset)
 
304
    elif timezone == 'local':
 
305
        tt = time.localtime(t)
 
306
        offset = local_time_offset(t)
 
307
    else:
 
308
        raise BzrError("unsupported timezone format %r" % timezone,
 
309
                       ['options are "utc", "original", "local"'])
 
310
    if date_fmt is None:
 
311
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
312
    if show_offset:
 
313
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
314
    else:
 
315
        offset_str = ''
 
316
    return (time.strftime(date_fmt, tt) +  offset_str)
 
317
 
 
318
 
 
319
def compact_date(when):
 
320
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
 
321
    
 
322
 
 
323
 
 
324
def filesize(f):
 
325
    """Return size of given open file."""
 
326
    return os.fstat(f.fileno())[ST_SIZE]
 
327
 
 
328
# Define rand_bytes based on platform.
 
329
try:
 
330
    # Python 2.4 and later have os.urandom,
 
331
    # but it doesn't work on some arches
 
332
    os.urandom(1)
 
333
    rand_bytes = os.urandom
 
334
except (NotImplementedError, AttributeError):
 
335
    # If python doesn't have os.urandom, or it doesn't work,
 
336
    # then try to first pull random data from /dev/urandom
 
337
    if os.path.exists("/dev/urandom"):
 
338
        rand_bytes = file('/dev/urandom', 'rb').read
 
339
    # Otherwise, use this hack as a last resort
 
340
    else:
 
341
        # not well seeded, but better than nothing
 
342
        def rand_bytes(n):
 
343
            import random
 
344
            s = ''
 
345
            while n:
 
346
                s += chr(random.randint(0, 255))
 
347
                n -= 1
 
348
            return s
 
349
 
 
350
## TODO: We could later have path objects that remember their list
 
351
## decomposition (might be too tricksy though.)
 
352
 
 
353
def splitpath(p):
 
354
    """Turn string into list of parts.
 
355
 
 
356
    >>> splitpath('a')
 
357
    ['a']
 
358
    >>> splitpath('a/b')
 
359
    ['a', 'b']
 
360
    >>> splitpath('a/./b')
 
361
    ['a', 'b']
 
362
    >>> splitpath('a/.b')
 
363
    ['a', '.b']
 
364
    >>> splitpath('a/../b')
 
365
    Traceback (most recent call last):
 
366
    ...
 
367
    BzrError: sorry, '..' not allowed in path
 
368
    """
 
369
    assert isinstance(p, types.StringTypes)
 
370
 
 
371
    # split on either delimiter because people might use either on
 
372
    # Windows
 
373
    ps = re.split(r'[\\/]', p)
 
374
 
 
375
    rps = []
 
376
    for f in ps:
 
377
        if f == '..':
 
378
            raise BzrError("sorry, %r not allowed in path" % f)
 
379
        elif (f == '.') or (f == ''):
 
380
            pass
 
381
        else:
 
382
            rps.append(f)
 
383
    return rps
 
384
 
 
385
def joinpath(p):
 
386
    assert isinstance(p, list)
 
387
    for f in p:
 
388
        if (f == '..') or (f == None) or (f == ''):
 
389
            raise BzrError("sorry, %r not allowed in path" % f)
 
390
    return os.path.join(*p)
 
391
 
 
392
 
 
393
def appendpath(p1, p2):
 
394
    if p1 == '':
 
395
        return p2
 
396
    else:
 
397
        return os.path.join(p1, p2)
 
398
    
 
399
 
 
400
def split_lines(s):
 
401
    """Split s into lines, but without removing the newline characters."""
 
402
    return StringIO(s).readlines()
 
403
 
 
404
 
 
405
def hardlinks_good():
 
406
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
407
 
 
408
 
 
409
def link_or_copy(src, dest):
 
410
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
411
    if not hardlinks_good():
 
412
        copyfile(src, dest)
 
413
        return
 
414
    try:
 
415
        os.link(src, dest)
 
416
    except (OSError, IOError), e:
 
417
        if e.errno != errno.EXDEV:
 
418
            raise
 
419
        copyfile(src, dest)
 
420
 
 
421
 
 
422
def has_symlinks():
 
423
    if hasattr(os, 'symlink'):
 
424
        return True
 
425
    else:
 
426
        return False
 
427
        
 
428
 
 
429
def contains_whitespace(s):
 
430
    """True if there are any whitespace characters in s."""
 
431
    for ch in string.whitespace:
 
432
        if ch in s:
 
433
            return True
 
434
    else:
 
435
        return False
 
436
 
 
437
 
 
438
def contains_linebreaks(s):
 
439
    """True if there is any vertical whitespace in s."""
 
440
    for ch in '\f\n\r':
 
441
        if ch in s:
 
442
            return True
 
443
    else:
 
444
        return False
 
445
 
 
446
 
 
447
def relpath(base, path):
 
448
    """Return path relative to base, or raise exception.
 
449
 
 
450
    The path may be either an absolute path or a path relative to the
 
451
    current working directory.
 
452
 
 
453
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
454
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
455
    avoids that problem."""
 
456
    rp = os.path.abspath(path)
 
457
 
 
458
    s = []
 
459
    head = rp
 
460
    while len(head) >= len(base):
 
461
        if head == base:
 
462
            break
 
463
        head, tail = os.path.split(head)
 
464
        if tail:
 
465
            s.insert(0, tail)
 
466
    else:
 
467
        # XXX This should raise a NotChildPath exception, as its not tied
 
468
        # to branch anymore.
 
469
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
470
 
 
471
    return os.sep.join(s)