← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

- rules for using destructors

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
1
# Bazaar-NG -- distributed version control
2
 
 
 
2
#
3
3
# Copyright (C) 2005 by Canonical Ltd
4
 
 
 
4
#
5
5
# This program is free software; you can redistribute it and/or modify
6
6
# it under the terms of the GNU General Public License as published by
7
7
# the Free Software Foundation; either version 2 of the License, or
8
8
# (at your option) any later version.
9
 
 
 
9
#
10
10
# This program is distributed in the hope that it will be useful,
11
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
13
# GNU General Public License for more details.
14
 
 
 
14
#
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
 
19
 
import os, types, re, time, types
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
 
 
22
 
from errors import bailout
 
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
 
23
36
 
24
37
def make_readonly(filename):
25
38
    """Make a filename read-only."""
26
 
    # TODO: probably needs to be fixed for windows
27
39
    mod = os.stat(filename).st_mode
28
40
    mod = mod & 0777555
29
41
    os.chmod(filename, mod)
35
47
    os.chmod(filename, mod)
36
48
 
37
49
 
38
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
50
_QUOTE_RE = None
 
51
 
 
52
 
39
53
def quotefn(f):
40
 
    """Return shell-quoted filename"""
41
 
    ## We could be a bit more terse by using double-quotes etc
42
 
    f = _QUOTE_RE.sub(r'\\\1', f)
43
 
    if f[0] == '~':
44
 
        f[0:1] = r'\~' 
45
 
    return 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
46
67
 
47
68
 
48
69
def file_kind(f):
53
74
        return 'directory'
54
75
    elif S_ISLNK(mode):
55
76
        return 'symlink'
56
 
    else:
57
 
        bailout("can't handle file kind with mode %o of %r" % (mode, f)) 
58
 
 
 
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
if os.name == "posix":
 
124
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
125
    # choke on a Unicode string containing a relative path if
 
126
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
127
    # string.
 
128
    _fs_enc = sys.getfilesystemencoding()
 
129
    def abspath(path):
 
130
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
 
131
    def realpath(path):
 
132
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
133
else:
 
134
    # We need to use the Unicode-aware os.path.abspath and
 
135
    # os.path.realpath on Windows systems.
 
136
    abspath = os.path.abspath
 
137
    realpath = os.path.realpath
 
138
 
 
139
def backup_file(fn):
 
140
    """Copy a file to a backup.
 
141
 
 
142
    Backups are named in GNU-style, with a ~ suffix.
 
143
 
 
144
    If the file is already a backup, it's not copied.
 
145
    """
 
146
    if fn[-1] == '~':
 
147
        return
 
148
    bfn = fn + '~'
 
149
 
 
150
    if has_symlinks() and os.path.islink(fn):
 
151
        target = os.readlink(fn)
 
152
        os.symlink(target, bfn)
 
153
        return
 
154
    inf = file(fn, 'rb')
 
155
    try:
 
156
        content = inf.read()
 
157
    finally:
 
158
        inf.close()
 
159
    
 
160
    outf = file(bfn, 'wb')
 
161
    try:
 
162
        outf.write(content)
 
163
    finally:
 
164
        outf.close()
 
165
 
 
166
if os.name == 'nt':
 
167
    import shutil
 
168
    rename = shutil.move
 
169
else:
 
170
    rename = os.rename
59
171
 
60
172
 
61
173
def isdir(f):
66
178
        return False
67
179
 
68
180
 
69
 
 
70
181
def isfile(f):
71
182
    """True if f is a regular file."""
72
183
    try:
74
185
    except OSError:
75
186
        return False
76
187
 
 
188
def islink(f):
 
189
    """True if f is a symlink."""
 
190
    try:
 
191
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
192
    except OSError:
 
193
        return False
 
194
 
 
195
def is_inside(dir, fname):
 
196
    """True if fname is inside dir.
 
197
    
 
198
    The parameters should typically be passed to os.path.normpath first, so
 
199
    that . and .. and repeated slashes are eliminated, and the separators
 
200
    are canonical for the platform.
 
201
    
 
202
    The empty string as a dir name is taken as top-of-tree and matches 
 
203
    everything.
 
204
    
 
205
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
206
    True
 
207
    >>> is_inside('src', 'srccontrol')
 
208
    False
 
209
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
210
    True
 
211
    >>> is_inside('foo.c', 'foo.c')
 
212
    True
 
213
    >>> is_inside('foo.c', '')
 
214
    False
 
215
    >>> is_inside('', 'foo.c')
 
216
    True
 
217
    """
 
218
    # XXX: Most callers of this can actually do something smarter by 
 
219
    # looking at the inventory
 
220
    if dir == fname:
 
221
        return True
 
222
    
 
223
    if dir == '':
 
224
        return True
 
225
 
 
226
    if dir[-1] != os.sep:
 
227
        dir += os.sep
 
228
 
 
229
    return fname.startswith(dir)
 
230
 
 
231
 
 
232
def is_inside_any(dir_list, fname):
 
233
    """True if fname is inside any of given dirs."""
 
234
    for dirname in dir_list:
 
235
        if is_inside(dirname, fname):
 
236
            return True
 
237
    else:
 
238
        return False
 
239
 
77
240
 
78
241
def pumpfile(fromfile, tofile):
79
242
    """Copy contents of one file to another."""
80
243
    tofile.write(fromfile.read())
81
244
 
82
245
 
83
 
def uuid():
84
 
    """Return a new UUID"""
85
 
    
86
 
    ## XXX: Could alternatively read /proc/sys/kernel/random/uuid on
87
 
    ## Linux, but we need something portable for other systems;
88
 
    ## preferably an implementation in Python.
89
 
    try:
90
 
        return chomp(file('/proc/sys/kernel/random/uuid').readline())
91
 
    except IOError:
92
 
        return chomp(os.popen('uuidgen').readline())
93
 
 
94
 
 
95
 
def chomp(s):
96
 
    if s and (s[-1] == '\n'):
97
 
        return s[:-1]
98
 
    else:
99
 
        return s
100
 
 
101
 
 
102
246
def sha_file(f):
103
 
    import sha
104
 
    ## TODO: Maybe read in chunks to handle big files
105
247
    if hasattr(f, 'tell'):
106
248
        assert f.tell() == 0
107
249
    s = sha.new()
108
 
    s.update(f.read())
 
250
    BUFSIZE = 128<<10
 
251
    while True:
 
252
        b = f.read(BUFSIZE)
 
253
        if not b:
 
254
            break
 
255
        s.update(b)
 
256
    return s.hexdigest()
 
257
 
 
258
 
 
259
 
 
260
def sha_strings(strings):
 
261
    """Return the sha-1 of concatenation of strings"""
 
262
    s = sha.new()
 
263
    map(s.update, strings)
109
264
    return s.hexdigest()
110
265
 
111
266
 
112
267
def sha_string(f):
113
 
    import sha
114
268
    s = sha.new()
115
269
    s.update(f)
116
270
    return s.hexdigest()
117
271
 
118
272
 
119
 
 
120
 
def username():
121
 
    """Return email-style username.
122
 
 
123
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
124
 
 
125
 
    :todo: Check it's reasonably well-formed.
126
 
 
127
 
    :todo: Allow taking it from a dotfile to help people on windows
128
 
           who can't easily set variables.
129
 
 
130
 
    :todo: Cope without pwd module, which is only on unix. 
131
 
    """
132
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
133
 
    if e: return e
134
 
 
135
 
    import socket
136
 
    
137
 
    try:
138
 
        import pwd
139
 
        uid = os.getuid()
140
 
        w = pwd.getpwuid(uid)
141
 
        gecos = w.pw_gecos
142
 
        comma = gecos.find(',')
143
 
        if comma == -1:
144
 
            realname = gecos
145
 
        else:
146
 
            realname = gecos[:comma]
147
 
        return '%s <%s@%s>' % (realname, w.pw_name, socket.getfqdn())
148
 
    except ImportError:
149
 
        pass
150
 
 
151
 
    import getpass, socket
152
 
    return '<%s@%s>' % (getpass.getuser(), socket.getfqdn())
153
 
 
154
 
 
155
 
def user_email():
156
 
    """Return just the email component of a username."""
157
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
158
 
    if e:
159
 
        import re
160
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
161
 
        if not m:
162
 
            bailout('%r is not a reasonable email address' % e)
163
 
        return m.group(0)
164
 
 
165
 
 
166
 
    import getpass, socket
167
 
    return '%s@%s' % (getpass.getuser(), socket.getfqdn())
168
 
 
169
 
    
 
273
def fingerprint_file(f):
 
274
    s = sha.new()
 
275
    b = f.read()
 
276
    s.update(b)
 
277
    size = len(b)
 
278
    return {'size': size,
 
279
            'sha1': s.hexdigest()}
170
280
 
171
281
 
172
282
def compare_files(a, b):
173
283
    """Returns true if equal in contents"""
174
 
    # TODO: don't read the whole thing in one go.
175
284
    BUFSIZE = 4096
176
285
    while True:
177
286
        ai = a.read(BUFSIZE)
182
291
            return True
183
292
 
184
293
 
185
 
 
186
294
def local_time_offset(t=None):
187
295
    """Return offset of local zone from GMT, either at present or at time t."""
188
296
    # python2.3 localtime() can't take None
189
 
    if t is None:
 
297
    if t == None:
190
298
        t = time.time()
191
299
        
192
300
    if time.localtime(t).tm_isdst and time.daylight:
195
303
        return -time.timezone
196
304
 
197
305
    
198
 
def format_date(t, offset=0, timezone='original'):
 
306
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
307
                show_offset=True):
199
308
    ## TODO: Perhaps a global option to use either universal or local time?
200
309
    ## Or perhaps just let people set $TZ?
201
 
    import time
202
 
    
203
310
    assert isinstance(t, float)
204
311
    
205
312
    if timezone == 'utc':
213
320
        tt = time.localtime(t)
214
321
        offset = local_time_offset(t)
215
322
    else:
216
 
        bailout("unsupported timezone format %r",
217
 
                ['options are "utc", "original", "local"'])
218
 
 
219
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
220
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
323
        raise BzrError("unsupported timezone format %r" % timezone,
 
324
                       ['options are "utc", "original", "local"'])
 
325
    if date_fmt is None:
 
326
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
327
    if show_offset:
 
328
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
329
    else:
 
330
        offset_str = ''
 
331
    return (time.strftime(date_fmt, tt) +  offset_str)
221
332
 
222
333
 
223
334
def compact_date(when):
229
340
    """Return size of given open file."""
230
341
    return os.fstat(f.fileno())[ST_SIZE]
231
342
 
232
 
 
233
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
343
# Define rand_bytes based on platform.
 
344
try:
 
345
    # Python 2.4 and later have os.urandom,
 
346
    # but it doesn't work on some arches
 
347
    os.urandom(1)
234
348
    rand_bytes = os.urandom
235
 
else:
236
 
    # FIXME: No good on non-Linux
237
 
    _rand_file = file('/dev/urandom', 'rb')
238
 
    rand_bytes = _rand_file.read
239
 
 
 
349
except (NotImplementedError, AttributeError):
 
350
    # If python doesn't have os.urandom, or it doesn't work,
 
351
    # then try to first pull random data from /dev/urandom
 
352
    if os.path.exists("/dev/urandom"):
 
353
        rand_bytes = file('/dev/urandom', 'rb').read
 
354
    # Otherwise, use this hack as a last resort
 
355
    else:
 
356
        # not well seeded, but better than nothing
 
357
        def rand_bytes(n):
 
358
            import random
 
359
            s = ''
 
360
            while n:
 
361
                s += chr(random.randint(0, 255))
 
362
                n -= 1
 
363
            return s
240
364
 
241
365
## TODO: We could later have path objects that remember their list
242
366
## decomposition (might be too tricksy though.)
255
379
    >>> splitpath('a/../b')
256
380
    Traceback (most recent call last):
257
381
    ...
258
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
382
    BzrError: sorry, '..' not allowed in path
259
383
    """
260
384
    assert isinstance(p, types.StringTypes)
261
 
    ps = [f for f in p.split('/') if f != '.']
 
385
 
 
386
    # split on either delimiter because people might use either on
 
387
    # Windows
 
388
    ps = re.split(r'[\\/]', p)
 
389
 
 
390
    rps = []
262
391
    for f in ps:
263
392
        if f == '..':
264
 
            bailout("sorry, %r not allowed in path" % f)
265
 
    return ps
 
393
            raise BzrError("sorry, %r not allowed in path" % f)
 
394
        elif (f == '.') or (f == ''):
 
395
            pass
 
396
        else:
 
397
            rps.append(f)
 
398
    return rps
266
399
 
267
400
def joinpath(p):
268
401
    assert isinstance(p, list)
269
402
    for f in p:
270
 
        if (f == '..') or (f is None) or (f == ''):
271
 
            bailout("sorry, %r not allowed in path" % f)
272
 
    return '/'.join(p)
 
403
        if (f == '..') or (f == None) or (f == ''):
 
404
            raise BzrError("sorry, %r not allowed in path" % f)
 
405
    return os.path.join(*p)
273
406
 
274
407
 
275
408
def appendpath(p1, p2):
276
409
    if p1 == '':
277
410
        return p2
278
411
    else:
279
 
        return p1 + '/' + p2
 
412
        return os.path.join(p1, p2)
280
413
    
281
414
 
282
 
def extern_command(cmd, ignore_errors = False):
283
 
    mutter('external command: %s' % `cmd`)
284
 
    if os.system(cmd):
285
 
        if not ignore_errors:
286
 
            bailout('command failed')
287
 
 
 
415
def split_lines(s):
 
416
    """Split s into lines, but without removing the newline characters."""
 
417
    return StringIO(s).readlines()
 
418
 
 
419
 
 
420
def hardlinks_good():
 
421
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
422
 
 
423
 
 
424
def link_or_copy(src, dest):
 
425
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
426
    if not hardlinks_good():
 
427
        copyfile(src, dest)
 
428
        return
 
429
    try:
 
430
        os.link(src, dest)
 
431
    except (OSError, IOError), e:
 
432
        if e.errno != errno.EXDEV:
 
433
            raise
 
434
        copyfile(src, dest)
 
435
 
 
436
 
 
437
def has_symlinks():
 
438
    if hasattr(os, 'symlink'):
 
439
        return True
 
440
    else:
 
441
        return False
 
442
        
 
443
 
 
444
def contains_whitespace(s):
 
445
    """True if there are any whitespace characters in s."""
 
446
    for ch in string.whitespace:
 
447
        if ch in s:
 
448
            return True
 
449
    else:
 
450
        return False
 
451
 
 
452
 
 
453
def contains_linebreaks(s):
 
454
    """True if there is any vertical whitespace in s."""
 
455
    for ch in '\f\n\r':
 
456
        if ch in s:
 
457
            return True
 
458
    else:
 
459
        return False
 
460
 
 
461
 
 
462
def relpath(base, path):
 
463
    """Return path relative to base, or raise exception.
 
464
 
 
465
    The path may be either an absolute path or a path relative to the
 
466
    current working directory.
 
467
 
 
468
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
469
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
470
    avoids that problem."""
 
471
    rp = abspath(path)
 
472
 
 
473
    s = []
 
474
    head = rp
 
475
    while len(head) >= len(base):
 
476
        if head == base:
 
477
            break
 
478
        head, tail = os.path.split(head)
 
479
        if tail:
 
480
            s.insert(0, tail)
 
481
    else:
 
482
        # XXX This should raise a NotChildPath exception, as its not tied
 
483
        # to branch anymore.
 
484
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
 
485
 
 
486
    return os.sep.join(s)