← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

- stub for revision properties

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 sys
 
28
import time
 
29
import types
 
30
 
 
31
import bzrlib
 
32
from bzrlib.config import config_dir, _get_user_id
 
33
from bzrlib.errors import BzrError
 
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
 
 
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
59
156
 
60
157
 
61
158
def isdir(f):
66
163
        return False
67
164
 
68
165
 
69
 
 
70
166
def isfile(f):
71
167
    """True if f is a regular file."""
72
168
    try:
74
170
    except OSError:
75
171
        return False
76
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
 
77
225
 
78
226
def pumpfile(fromfile, tofile):
79
227
    """Copy contents of one file to another."""
80
228
    tofile.write(fromfile.read())
81
229
 
82
230
 
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
 
    bailout('uuids not allowed!')
90
 
    return chomp(os.popen('uuidgen').readline())
91
 
 
92
 
def chomp(s):
93
 
    if s and (s[-1] == '\n'):
94
 
        return s[:-1]
95
 
    else:
96
 
        return s
97
 
 
98
 
 
99
231
def sha_file(f):
100
 
    import sha
101
 
    ## TODO: Maybe read in chunks to handle big files
102
232
    if hasattr(f, 'tell'):
103
233
        assert f.tell() == 0
104
234
    s = sha.new()
105
 
    s.update(f.read())
 
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)
106
249
    return s.hexdigest()
107
250
 
108
251
 
109
252
def sha_string(f):
110
 
    import sha
111
253
    s = sha.new()
112
254
    s.update(f)
113
255
    return s.hexdigest()
114
256
 
115
257
 
116
 
 
117
 
def username():
118
 
    """Return email-style username.
119
 
 
120
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
121
 
 
122
 
    :todo: Check it's reasonably well-formed.
123
 
 
124
 
    :todo: Allow taking it from a dotfile to help people on windows
125
 
           who can't easily set variables.
126
 
 
127
 
    :todo: Cope without pwd module, which is only on unix. 
128
 
    """
129
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
130
 
    if e: return e
131
 
 
132
 
    import socket
133
 
    
134
 
    try:
135
 
        import pwd
136
 
        uid = os.getuid()
137
 
        w = pwd.getpwuid(uid)
138
 
        gecos = w.pw_gecos
139
 
        comma = gecos.find(',')
140
 
        if comma == -1:
141
 
            realname = gecos
142
 
        else:
143
 
            realname = gecos[:comma]
144
 
        return '%s <%s@%s>' % (realname, w.pw_name, socket.getfqdn())
145
 
    except ImportError:
146
 
        pass
147
 
 
148
 
    import getpass, socket
149
 
    return '<%s@%s>' % (getpass.getuser(), socket.getfqdn())
150
 
 
151
 
 
152
 
def user_email():
153
 
    """Return just the email component of a username."""
154
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
155
 
    if e:
156
 
        import re
157
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
158
 
        if not m:
159
 
            bailout('%r is not a reasonable email address' % e)
160
 
        return m.group(0)
161
 
 
162
 
 
163
 
    import getpass, socket
164
 
    return '%s@%s' % (getpass.getuser(), socket.getfqdn())
165
 
 
166
 
    
 
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()}
167
265
 
168
266
 
169
267
def compare_files(a, b):
170
268
    """Returns true if equal in contents"""
171
 
    # TODO: don't read the whole thing in one go.
172
 
    result = a.read() == b.read()
173
 
    return result
174
 
 
175
 
 
176
 
 
177
 
def local_time_offset():
178
 
    if time.daylight:
 
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:
179
286
        return -time.altzone
180
287
    else:
181
288
        return -time.timezone
184
291
def format_date(t, offset=0, timezone='original'):
185
292
    ## TODO: Perhaps a global option to use either universal or local time?
186
293
    ## Or perhaps just let people set $TZ?
187
 
    import time
188
 
    
189
294
    assert isinstance(t, float)
190
295
    
191
296
    if timezone == 'utc':
197
302
        tt = time.gmtime(t + offset)
198
303
    elif timezone == 'local':
199
304
        tt = time.localtime(t)
200
 
        offset = local_time_offset()
 
305
        offset = local_time_offset(t)
201
306
    else:
202
 
        bailout("unsupported timezone format %r",
203
 
                ['options are "utc", "original", "local"'])
 
307
        raise BzrError("unsupported timezone format %r" % timezone,
 
308
                       ['options are "utc", "original", "local"'])
204
309
 
205
310
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
206
311
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
215
320
    """Return size of given open file."""
216
321
    return os.fstat(f.fileno())[ST_SIZE]
217
322
 
218
 
 
219
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
323
# Define rand_bytes based on platform.
 
324
try:
 
325
    # Python 2.4 and later have os.urandom,
 
326
    # but it doesn't work on some arches
 
327
    os.urandom(1)
220
328
    rand_bytes = os.urandom
221
 
else:
222
 
    # FIXME: No good on non-Linux
223
 
    _rand_file = file('/dev/urandom', 'rb')
224
 
    rand_bytes = _rand_file.read
225
 
 
 
329
except (NotImplementedError, AttributeError):
 
330
    # If python doesn't have os.urandom, or it doesn't work,
 
331
    # then try to first pull random data from /dev/urandom
 
332
    if os.path.exists("/dev/urandom"):
 
333
        rand_bytes = file('/dev/urandom', 'rb').read
 
334
    # Otherwise, use this hack as a last resort
 
335
    else:
 
336
        # not well seeded, but better than nothing
 
337
        def rand_bytes(n):
 
338
            import random
 
339
            s = ''
 
340
            while n:
 
341
                s += chr(random.randint(0, 255))
 
342
                n -= 1
 
343
            return s
226
344
 
227
345
## TODO: We could later have path objects that remember their list
228
346
## decomposition (might be too tricksy though.)
241
359
    >>> splitpath('a/../b')
242
360
    Traceback (most recent call last):
243
361
    ...
244
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
362
    BzrError: sorry, '..' not allowed in path
245
363
    """
246
364
    assert isinstance(p, types.StringTypes)
247
 
    ps = [f for f in p.split('/') if f != '.']
 
365
 
 
366
    # split on either delimiter because people might use either on
 
367
    # Windows
 
368
    ps = re.split(r'[\\/]', p)
 
369
 
 
370
    rps = []
248
371
    for f in ps:
249
372
        if f == '..':
250
 
            bailout("sorry, %r not allowed in path" % f)
251
 
    return ps
 
373
            raise BzrError("sorry, %r not allowed in path" % f)
 
374
        elif (f == '.') or (f == ''):
 
375
            pass
 
376
        else:
 
377
            rps.append(f)
 
378
    return rps
252
379
 
253
380
def joinpath(p):
254
381
    assert isinstance(p, list)
255
382
    for f in p:
256
 
        if (f == '..') or (f is None) or (f == ''):
257
 
            bailout("sorry, %r not allowed in path" % f)
258
 
    return '/'.join(p)
 
383
        if (f == '..') or (f == None) or (f == ''):
 
384
            raise BzrError("sorry, %r not allowed in path" % f)
 
385
    return os.path.join(*p)
259
386
 
260
387
 
261
388
def appendpath(p1, p2):
262
389
    if p1 == '':
263
390
        return p2
264
391
    else:
265
 
        return p1 + '/' + p2
 
392
        return os.path.join(p1, p2)
266
393
    
267
394
 
268
 
def extern_command(cmd, ignore_errors = False):
269
 
    mutter('external command: %s' % `cmd`)
270
 
    if os.system(cmd):
271
 
        if not ignore_errors:
272
 
            bailout('command failed')
273
 
 
 
395
def split_lines(s):
 
396
    """Split s into lines, but without removing the newline characters."""
 
397
    return StringIO(s).readlines()
 
398
 
 
399
 
 
400
def hardlinks_good():
 
401
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
402
 
 
403
 
 
404
def link_or_copy(src, dest):
 
405
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
406
    if not hardlinks_good():
 
407
        copyfile(src, dest)
 
408
        return
 
409
    try:
 
410
        os.link(src, dest)
 
411
    except (OSError, IOError), e:
 
412
        if e.errno != errno.EXDEV:
 
413
            raise
 
414
        copyfile(src, dest)
 
415
 
 
416
 
 
417
def has_symlinks():
 
418
    if hasattr(os, 'symlink'):
 
419
        return True
 
420
    else:
 
421
        return False