← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Really enter the debugger on failure

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, errno, sys
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
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
21
31
 
22
 
from errors import bailout, BzrError
23
 
from trace import mutter
24
32
import bzrlib
 
33
from bzrlib.errors import BzrError, NotBranchError
 
34
from bzrlib.trace import mutter
 
35
 
25
36
 
26
37
def make_readonly(filename):
27
38
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
39
    mod = os.stat(filename).st_mode
30
40
    mod = mod & 0777555
31
41
    os.chmod(filename, mod)
37
47
    os.chmod(filename, mod)
38
48
 
39
49
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
50
_QUOTE_RE = None
 
51
 
 
52
 
41
53
def quotefn(f):
42
 
    """Return shell-quoted filename"""
43
 
    ## We could be a bit more terse by using double-quotes etc
44
 
    f = _QUOTE_RE.sub(r'\\\1', f)
45
 
    if f[0] == '~':
46
 
        f[0:1] = r'\~' 
47
 
    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
48
67
 
49
68
 
50
69
def file_kind(f):
55
74
        return 'directory'
56
75
    elif S_ISLNK(mode):
57
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'
58
85
    else:
59
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
 
86
        return 'unknown'
60
87
 
61
88
 
62
89
def kind_marker(kind):
69
96
    else:
70
97
        raise BzrError('invalid file kind %r' % kind)
71
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
72
171
 
73
172
 
74
173
def isdir(f):
79
178
        return False
80
179
 
81
180
 
82
 
 
83
181
def isfile(f):
84
182
    """True if f is a regular file."""
85
183
    try:
87
185
    except OSError:
88
186
        return False
89
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
90
194
 
91
195
def is_inside(dir, fname):
92
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
93
217
    """
94
 
    return os.path.commonprefix([dir, fname]) == dir
 
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)
95
230
 
96
231
 
97
232
def is_inside_any(dir_list, fname):
98
233
    """True if fname is inside any of given dirs."""
99
 
    # quick scan for perfect match
100
 
    if fname in dir_list:
101
 
        return True
102
 
    
103
234
    for dirname in dir_list:
104
235
        if is_inside(dirname, fname):
105
236
            return True
112
243
    tofile.write(fromfile.read())
113
244
 
114
245
 
115
 
def uuid():
116
 
    """Return a new UUID"""
117
 
    try:
118
 
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
119
 
    except IOError:
120
 
        return chomp(os.popen('uuidgen').readline())
121
 
 
122
 
 
123
246
def sha_file(f):
124
 
    import sha
125
247
    if hasattr(f, 'tell'):
126
248
        assert f.tell() == 0
127
249
    s = sha.new()
134
256
    return s.hexdigest()
135
257
 
136
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)
 
264
    return s.hexdigest()
 
265
 
 
266
 
137
267
def sha_string(f):
138
 
    import sha
139
268
    s = sha.new()
140
269
    s.update(f)
141
270
    return s.hexdigest()
142
271
 
143
272
 
144
 
 
145
273
def fingerprint_file(f):
146
 
    import sha
147
274
    s = sha.new()
148
275
    b = f.read()
149
276
    s.update(b)
152
279
            'sha1': s.hexdigest()}
153
280
 
154
281
 
155
 
def config_dir():
156
 
    """Return per-user configuration directory.
157
 
 
158
 
    By default this is ~/.bzr.conf/
159
 
    
160
 
    TODO: Global option --config-dir to override this.
161
 
    """
162
 
    return os.path.expanduser("~/.bzr.conf")
163
 
 
164
 
 
165
 
def _auto_user_id():
166
 
    """Calculate automatic user identification.
167
 
 
168
 
    Returns (realname, email).
169
 
 
170
 
    Only used when none is set in the environment or the id file.
171
 
 
172
 
    This previously used the FQDN as the default domain, but that can
173
 
    be very slow on machines where DNS is broken.  So now we simply
174
 
    use the hostname.
175
 
    """
176
 
    import socket
177
 
 
178
 
    # XXX: Any good way to get real user name on win32?
179
 
 
180
 
    try:
181
 
        import pwd
182
 
        uid = os.getuid()
183
 
        w = pwd.getpwuid(uid)
184
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
185
 
        username = w.pw_name.decode(bzrlib.user_encoding)
186
 
        comma = gecos.find(',')
187
 
        if comma == -1:
188
 
            realname = gecos
189
 
        else:
190
 
            realname = gecos[:comma]
191
 
        if not realname:
192
 
            realname = username
193
 
 
194
 
    except ImportError:
195
 
        import getpass
196
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
197
 
 
198
 
    return realname, (username + '@' + socket.gethostname())
199
 
 
200
 
 
201
 
def _get_user_id():
202
 
    """Return the full user id from a file or environment variable.
203
 
 
204
 
    TODO: Allow taking this from a file in the branch directory too
205
 
    for per-branch ids."""
206
 
    v = os.environ.get('BZREMAIL')
207
 
    if v:
208
 
        return v.decode(bzrlib.user_encoding)
209
 
    
210
 
    try:
211
 
        return (open(os.path.join(config_dir(), "email"))
212
 
                .read()
213
 
                .decode(bzrlib.user_encoding)
214
 
                .rstrip("\r\n"))
215
 
    except IOError, e:
216
 
        if e.errno != errno.ENOENT:
217
 
            raise e
218
 
 
219
 
    v = os.environ.get('EMAIL')
220
 
    if v:
221
 
        return v.decode(bzrlib.user_encoding)
222
 
    else:    
223
 
        return None
224
 
 
225
 
 
226
 
def username():
227
 
    """Return email-style username.
228
 
 
229
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
230
 
 
231
 
    TODO: Check it's reasonably well-formed.
232
 
    """
233
 
    v = _get_user_id()
234
 
    if v:
235
 
        return v
236
 
    
237
 
    name, email = _auto_user_id()
238
 
    if name:
239
 
        return '%s <%s>' % (name, email)
240
 
    else:
241
 
        return email
242
 
 
243
 
 
244
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
245
 
def user_email():
246
 
    """Return just the email component of a username."""
247
 
    e = _get_user_id()
248
 
    if e:
249
 
        m = _EMAIL_RE.search(e)
250
 
        if not m:
251
 
            bailout("%r doesn't seem to contain a reasonable email address" % e)
252
 
        return m.group(0)
253
 
 
254
 
    return _auto_user_id()[1]
255
 
    
256
 
 
257
 
 
258
282
def compare_files(a, b):
259
283
    """Returns true if equal in contents"""
260
284
    BUFSIZE = 4096
267
291
            return True
268
292
 
269
293
 
270
 
 
271
294
def local_time_offset(t=None):
272
295
    """Return offset of local zone from GMT, either at present or at time t."""
273
296
    # python2.3 localtime() can't take None
280
303
        return -time.timezone
281
304
 
282
305
    
283
 
def format_date(t, offset=0, timezone='original'):
 
306
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
307
                show_offset=True):
284
308
    ## TODO: Perhaps a global option to use either universal or local time?
285
309
    ## Or perhaps just let people set $TZ?
286
310
    assert isinstance(t, float)
296
320
        tt = time.localtime(t)
297
321
        offset = local_time_offset(t)
298
322
    else:
299
 
        bailout("unsupported timezone format %r",
300
 
                ['options are "utc", "original", "local"'])
301
 
 
302
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
303
 
            + ' %+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)
304
332
 
305
333
 
306
334
def compact_date(when):
312
340
    """Return size of given open file."""
313
341
    return os.fstat(f.fileno())[ST_SIZE]
314
342
 
315
 
 
316
 
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)
317
348
    rand_bytes = os.urandom
318
 
elif sys.platform == 'linux2':
319
 
    rand_bytes = file('/dev/urandom', 'rb').read
320
 
else:
321
 
    # not well seeded, but better than nothing
322
 
    def rand_bytes(n):
323
 
        import random
324
 
        s = ''
325
 
        while n:
326
 
            s += chr(random.randint(0, 255))
327
 
            n -= 1
328
 
        return s
329
 
 
 
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
330
364
 
331
365
## TODO: We could later have path objects that remember their list
332
366
## decomposition (might be too tricksy though.)
345
379
    >>> splitpath('a/../b')
346
380
    Traceback (most recent call last):
347
381
    ...
348
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
382
    BzrError: sorry, '..' not allowed in path
349
383
    """
350
384
    assert isinstance(p, types.StringTypes)
351
385
 
356
390
    rps = []
357
391
    for f in ps:
358
392
        if f == '..':
359
 
            bailout("sorry, %r not allowed in path" % f)
 
393
            raise BzrError("sorry, %r not allowed in path" % f)
360
394
        elif (f == '.') or (f == ''):
361
395
            pass
362
396
        else:
367
401
    assert isinstance(p, list)
368
402
    for f in p:
369
403
        if (f == '..') or (f == None) or (f == ''):
370
 
            bailout("sorry, %r not allowed in path" % f)
 
404
            raise BzrError("sorry, %r not allowed in path" % f)
371
405
    return os.path.join(*p)
372
406
 
373
407
 
378
412
        return os.path.join(p1, p2)
379
413
    
380
414
 
381
 
def extern_command(cmd, ignore_errors = False):
382
 
    mutter('external command: %s' % `cmd`)
383
 
    if os.system(cmd):
384
 
        if not ignore_errors:
385
 
            bailout('command failed')
386
 
 
 
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)