← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Update news and readme

- better explanation of dependencies

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
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
 
 
22
 
from errors import bailout, BzrError
23
 
from trace import mutter
 
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
 
24
36
 
25
37
def make_readonly(filename):
26
38
    """Make a filename read-only."""
27
 
    # TODO: probably needs to be fixed for windows
28
39
    mod = os.stat(filename).st_mode
29
40
    mod = mod & 0777555
30
41
    os.chmod(filename, mod)
36
47
    os.chmod(filename, mod)
37
48
 
38
49
 
39
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
50
_QUOTE_RE = None
 
51
 
 
52
 
40
53
def quotefn(f):
41
 
    """Return shell-quoted filename"""
42
 
    ## We could be a bit more terse by using double-quotes etc
43
 
    f = _QUOTE_RE.sub(r'\\\1', f)
44
 
    if f[0] == '~':
45
 
        f[0:1] = r'\~' 
46
 
    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
47
67
 
48
68
 
49
69
def file_kind(f):
54
74
        return 'directory'
55
75
    elif S_ISLNK(mode):
56
76
        return 'symlink'
57
 
    else:
58
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f)) 
59
 
 
 
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
60
171
 
61
172
 
62
173
def isdir(f):
67
178
        return False
68
179
 
69
180
 
70
 
 
71
181
def isfile(f):
72
182
    """True if f is a regular file."""
73
183
    try:
75
185
    except OSError:
76
186
        return False
77
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
 
78
240
 
79
241
def pumpfile(fromfile, tofile):
80
242
    """Copy contents of one file to another."""
81
243
    tofile.write(fromfile.read())
82
244
 
83
245
 
84
 
def uuid():
85
 
    """Return a new UUID"""
86
 
    
87
 
    ## XXX: Could alternatively read /proc/sys/kernel/random/uuid on
88
 
    ## Linux, but we need something portable for other systems;
89
 
    ## preferably an implementation in Python.
90
 
    try:
91
 
        return chomp(file('/proc/sys/kernel/random/uuid').readline())
92
 
    except IOError:
93
 
        return chomp(os.popen('uuidgen').readline())
94
 
 
95
 
 
96
 
def chomp(s):
97
 
    if s and (s[-1] == '\n'):
98
 
        return s[:-1]
99
 
    else:
100
 
        return s
101
 
 
102
 
 
103
246
def sha_file(f):
104
 
    import sha
105
 
    ## TODO: Maybe read in chunks to handle big files
106
247
    if hasattr(f, 'tell'):
107
248
        assert f.tell() == 0
108
249
    s = sha.new()
109
 
    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)
110
264
    return s.hexdigest()
111
265
 
112
266
 
113
267
def sha_string(f):
114
 
    import sha
115
268
    s = sha.new()
116
269
    s.update(f)
117
270
    return s.hexdigest()
118
271
 
119
272
 
120
 
 
121
273
def fingerprint_file(f):
122
 
    import sha
123
274
    s = sha.new()
124
275
    b = f.read()
125
276
    s.update(b)
128
279
            'sha1': s.hexdigest()}
129
280
 
130
281
 
131
 
 
132
 
def username():
133
 
    """Return email-style username.
134
 
 
135
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
136
 
 
137
 
    :todo: Check it's reasonably well-formed.
138
 
 
139
 
    :todo: Allow taking it from a dotfile to help people on windows
140
 
           who can't easily set variables.
141
 
 
142
 
    :todo: Cope without pwd module, which is only on unix. 
143
 
    """
144
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
145
 
    if e: return e
146
 
 
147
 
    import socket
148
 
    
149
 
    try:
150
 
        import pwd
151
 
        uid = os.getuid()
152
 
        w = pwd.getpwuid(uid)
153
 
        gecos = w.pw_gecos
154
 
        comma = gecos.find(',')
155
 
        if comma == -1:
156
 
            realname = gecos
157
 
        else:
158
 
            realname = gecos[:comma]
159
 
        return '%s <%s@%s>' % (realname, w.pw_name, socket.getfqdn())
160
 
    except ImportError:
161
 
        pass
162
 
 
163
 
    import getpass, socket
164
 
    return '<%s@%s>' % (getpass.getuser(), socket.getfqdn())
165
 
 
166
 
 
167
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
168
 
def user_email():
169
 
    """Return just the email component of a username."""
170
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
171
 
    if e:
172
 
        m = _EMAIL_RE.search(e)
173
 
        if not m:
174
 
            bailout('%r is not a reasonable email address' % e)
175
 
        return m.group(0)
176
 
 
177
 
 
178
 
    import getpass, socket
179
 
    return '%s@%s' % (getpass.getuser(), socket.getfqdn())
180
 
 
181
 
    
182
 
 
183
 
 
184
282
def compare_files(a, b):
185
283
    """Returns true if equal in contents"""
186
 
    # TODO: don't read the whole thing in one go.
187
284
    BUFSIZE = 4096
188
285
    while True:
189
286
        ai = a.read(BUFSIZE)
194
291
            return True
195
292
 
196
293
 
197
 
 
198
294
def local_time_offset(t=None):
199
295
    """Return offset of local zone from GMT, either at present or at time t."""
200
296
    # python2.3 localtime() can't take None
207
303
        return -time.timezone
208
304
 
209
305
    
210
 
def format_date(t, offset=0, timezone='original'):
 
306
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
307
                show_offset=True):
211
308
    ## TODO: Perhaps a global option to use either universal or local time?
212
309
    ## Or perhaps just let people set $TZ?
213
310
    assert isinstance(t, float)
223
320
        tt = time.localtime(t)
224
321
        offset = local_time_offset(t)
225
322
    else:
226
 
        bailout("unsupported timezone format %r",
227
 
                ['options are "utc", "original", "local"'])
228
 
 
229
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
230
 
            + ' %+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)
231
332
 
232
333
 
233
334
def compact_date(when):
239
340
    """Return size of given open file."""
240
341
    return os.fstat(f.fileno())[ST_SIZE]
241
342
 
242
 
 
243
 
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)
244
348
    rand_bytes = os.urandom
245
 
else:
246
 
    # FIXME: No good on non-Linux
247
 
    _rand_file = file('/dev/urandom', 'rb')
248
 
    rand_bytes = _rand_file.read
249
 
 
 
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
250
364
 
251
365
## TODO: We could later have path objects that remember their list
252
366
## decomposition (might be too tricksy though.)
265
379
    >>> splitpath('a/../b')
266
380
    Traceback (most recent call last):
267
381
    ...
268
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
382
    BzrError: sorry, '..' not allowed in path
269
383
    """
270
384
    assert isinstance(p, types.StringTypes)
271
 
    ps = [f for f in p.split('/') if (f != '.' and f != '')]
 
385
 
 
386
    # split on either delimiter because people might use either on
 
387
    # Windows
 
388
    ps = re.split(r'[\\/]', p)
 
389
 
 
390
    rps = []
272
391
    for f in ps:
273
392
        if f == '..':
274
 
            bailout("sorry, %r not allowed in path" % f)
275
 
    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
276
399
 
277
400
def joinpath(p):
278
401
    assert isinstance(p, list)
279
402
    for f in p:
280
403
        if (f == '..') or (f == None) or (f == ''):
281
 
            bailout("sorry, %r not allowed in path" % f)
282
 
    return '/'.join(p)
 
404
            raise BzrError("sorry, %r not allowed in path" % f)
 
405
    return os.path.join(*p)
283
406
 
284
407
 
285
408
def appendpath(p1, p2):
286
409
    if p1 == '':
287
410
        return p2
288
411
    else:
289
 
        return p1 + '/' + p2
 
412
        return os.path.join(p1, p2)
290
413
    
291
414
 
292
 
def extern_command(cmd, ignore_errors = False):
293
 
    mutter('external command: %s' % `cmd`)
294
 
    if os.system(cmd):
295
 
        if not ignore_errors:
296
 
            bailout('command failed')
297
 
 
 
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)