← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2005-10-30 00:00:09 UTC
  • mfrom: (1185.16.134)
  • Revision ID: robertc@robertcollins.net-20051030000009-9db99a338a0dfdac
Merge from Martin.

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, 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):
51
72
        return 'file'
52
73
    elif S_ISDIR(mode):
53
74
        return 'directory'
54
 
    else:
55
 
        bailout("can't handle file kind of %r" % fp)
56
 
 
 
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
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
57
171
 
58
172
 
59
173
def isdir(f):
64
178
        return False
65
179
 
66
180
 
67
 
 
68
181
def isfile(f):
69
182
    """True if f is a regular file."""
70
183
    try:
72
185
    except OSError:
73
186
        return False
74
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
 
75
240
 
76
241
def pumpfile(fromfile, tofile):
77
242
    """Copy contents of one file to another."""
78
243
    tofile.write(fromfile.read())
79
244
 
80
245
 
81
 
def uuid():
82
 
    """Return a new UUID"""
83
 
    
84
 
    ## XXX: Could alternatively read /proc/sys/kernel/random/uuid on
85
 
    ## Linux, but we need something portable for other systems;
86
 
    ## preferably an implementation in Python.
87
 
    bailout('uuids not allowed!')
88
 
    return chomp(os.popen('uuidgen').readline())
89
 
 
90
 
def chomp(s):
91
 
    if s and (s[-1] == '\n'):
92
 
        return s[:-1]
93
 
    else:
94
 
        return s
95
 
 
96
 
 
97
246
def sha_file(f):
98
 
    import sha
99
 
    ## TODO: Maybe read in chunks to handle big files
100
247
    if hasattr(f, 'tell'):
101
248
        assert f.tell() == 0
102
249
    s = sha.new()
103
 
    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)
104
264
    return s.hexdigest()
105
265
 
106
266
 
107
267
def sha_string(f):
108
 
    import sha
109
268
    s = sha.new()
110
269
    s.update(f)
111
270
    return s.hexdigest()
112
271
 
113
272
 
114
 
 
115
 
def username():
116
 
    """Return email-style username.
117
 
 
118
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
119
 
 
120
 
    :todo: Check it's reasonably well-formed.
121
 
 
122
 
    :todo: Allow taking it from a dotfile to help people on windows
123
 
           who can't easily set variables.
124
 
 
125
 
    :todo: Cope without pwd module, which is only on unix. 
126
 
    """
127
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
128
 
    if e: return e
129
 
 
130
 
    import socket
131
 
    
132
 
    try:
133
 
        import pwd
134
 
        uid = os.getuid()
135
 
        w = pwd.getpwuid(uid)
136
 
        realname, junk = w.pw_gecos.split(',', 1)
137
 
        return '%s <%s@%s>' % (realname, w.pw_name, socket.getfqdn())
138
 
    except ImportError:
139
 
        pass
140
 
 
141
 
    import getpass, socket
142
 
    return '<%s@%s>' % (getpass.getuser(), socket.getfqdn())
143
 
 
144
 
 
145
 
def user_email():
146
 
    """Return just the email component of a username."""
147
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
148
 
    if e:
149
 
        import re
150
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
151
 
        if not m:
152
 
            bailout('%r is not a reasonable email address' % e)
153
 
        return m.group(0)
154
 
 
155
 
 
156
 
    import getpass, socket
157
 
    return '%s@%s' % (getpass.getuser(), socket.getfqdn())
158
 
 
159
 
    
 
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()}
160
280
 
161
281
 
162
282
def compare_files(a, b):
163
283
    """Returns true if equal in contents"""
164
 
    # TODO: don't read the whole thing in one go.
165
 
    result = a.read() == b.read()
166
 
    return result
167
 
 
168
 
 
169
 
 
170
 
def format_date(t, inutc=False):
 
284
    BUFSIZE = 4096
 
285
    while True:
 
286
        ai = a.read(BUFSIZE)
 
287
        bi = b.read(BUFSIZE)
 
288
        if ai != bi:
 
289
            return False
 
290
        if ai == '':
 
291
            return True
 
292
 
 
293
 
 
294
def local_time_offset(t=None):
 
295
    """Return offset of local zone from GMT, either at present or at time t."""
 
296
    # python2.3 localtime() can't take None
 
297
    if t == None:
 
298
        t = time.time()
 
299
        
 
300
    if time.localtime(t).tm_isdst and time.daylight:
 
301
        return -time.altzone
 
302
    else:
 
303
        return -time.timezone
 
304
 
 
305
    
 
306
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
307
                show_offset=True):
171
308
    ## TODO: Perhaps a global option to use either universal or local time?
172
309
    ## Or perhaps just let people set $TZ?
173
 
    import time
174
 
    
175
310
    assert isinstance(t, float)
176
311
    
177
 
    if inutc:
 
312
    if timezone == 'utc':
178
313
        tt = time.gmtime(t)
179
 
        zonename = 'UTC'
180
314
        offset = 0
181
 
    else:
 
315
    elif timezone == 'original':
 
316
        if offset == None:
 
317
            offset = 0
 
318
        tt = time.gmtime(t + offset)
 
319
    elif timezone == 'local':
182
320
        tt = time.localtime(t)
183
 
        if time.daylight:
184
 
            zonename = time.tzname[1]
185
 
            offset = - time.altzone
186
 
        else:
187
 
            zonename = time.tzname[0]
188
 
            offset = - time.timezone
189
 
            
190
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
191
 
            + ' ' + zonename + ' '
192
 
            + '%+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
321
        offset = local_time_offset(t)
 
322
    else:
 
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)
193
332
 
194
333
 
195
334
def compact_date(when):
201
340
    """Return size of given open file."""
202
341
    return os.fstat(f.fileno())[ST_SIZE]
203
342
 
204
 
 
205
 
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)
206
348
    rand_bytes = os.urandom
207
 
else:
208
 
    # FIXME: No good on non-Linux
209
 
    _rand_file = file('/dev/urandom', 'rb')
210
 
    rand_bytes = _rand_file.read
211
 
 
 
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
212
364
 
213
365
## TODO: We could later have path objects that remember their list
214
366
## decomposition (might be too tricksy though.)
227
379
    >>> splitpath('a/../b')
228
380
    Traceback (most recent call last):
229
381
    ...
230
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
382
    BzrError: sorry, '..' not allowed in path
231
383
    """
232
384
    assert isinstance(p, types.StringTypes)
233
 
    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 = []
234
391
    for f in ps:
235
392
        if f == '..':
236
 
            bailout("sorry, %r not allowed in path" % f)
237
 
    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
238
399
 
239
400
def joinpath(p):
240
401
    assert isinstance(p, list)
241
402
    for f in p:
242
 
        if (f == '..') or (f is None) or (f == ''):
243
 
            bailout("sorry, %r not allowed in path" % f)
244
 
    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)
245
406
 
246
407
 
247
408
def appendpath(p1, p2):
248
409
    if p1 == '':
249
410
        return p2
250
411
    else:
251
 
        return p1 + '/' + p2
 
412
        return os.path.join(p1, p2)
252
413
    
253
414
 
254
 
def extern_command(cmd, ignore_errors = False):
255
 
    mutter('external command: %s' % `cmd`)
256
 
    if os.system(cmd):
257
 
        if not ignore_errors:
258
 
            bailout('command failed')
259
 
 
 
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)