~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2005-06-15 04:17:12 UTC
  • Revision ID: mbp@sourcefrog.net-20050615041712-ba12ff03d4ce3be0
- add deferred patch from abentley 
  to fetch remote Revision XML only once
  when branching

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
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
 
19
import os, types, re, time, errno, sys
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
31
21
 
 
22
from errors import bailout, BzrError
 
23
from trace import mutter
32
24
import bzrlib
33
 
from bzrlib.config import config_dir, _get_user_id
34
 
from bzrlib.errors import BzrError
35
 
from bzrlib.trace import mutter
36
 
 
37
25
 
38
26
def make_readonly(filename):
39
27
    """Make a filename read-only."""
 
28
    # TODO: probably needs to be fixed for windows
40
29
    mod = os.stat(filename).st_mode
41
30
    mod = mod & 0777555
42
31
    os.chmod(filename, mod)
48
37
    os.chmod(filename, mod)
49
38
 
50
39
 
51
 
_QUOTE_RE = None
52
 
 
53
 
 
 
40
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
54
41
def quotefn(f):
55
 
    """Return a quoted filename filename
56
 
 
57
 
    This previously used backslash quoting, but that works poorly on
58
 
    Windows."""
59
 
    # TODO: I'm not really sure this is the best format either.x
60
 
    global _QUOTE_RE
61
 
    if _QUOTE_RE == None:
62
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
63
 
        
64
 
    if _QUOTE_RE.search(f):
65
 
        return '"' + f + '"'
66
 
    else:
67
 
        return 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
68
48
 
69
49
 
70
50
def file_kind(f):
75
55
        return 'directory'
76
56
    elif S_ISLNK(mode):
77
57
        return 'symlink'
78
 
    elif S_ISCHR(mode):
79
 
        return 'chardev'
80
 
    elif S_ISBLK(mode):
81
 
        return 'block'
82
 
    elif S_ISFIFO(mode):
83
 
        return 'fifo'
84
 
    elif S_ISSOCK(mode):
85
 
        return 'socket'
86
58
    else:
87
 
        return 'unknown'
 
59
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
88
60
 
89
61
 
90
62
def kind_marker(kind):
97
69
    else:
98
70
        raise BzrError('invalid file kind %r' % kind)
99
71
 
100
 
def lexists(f):
101
 
    try:
102
 
        if hasattr(os, 'lstat'):
103
 
            os.lstat(f)
104
 
        else:
105
 
            os.stat(f)
106
 
        return True
107
 
    except OSError,e:
108
 
        if e.errno == errno.ENOENT:
109
 
            return False;
110
 
        else:
111
 
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
112
 
 
113
 
def normalizepath(f):
114
 
    if hasattr(os.path, 'realpath'):
115
 
        F = os.path.realpath
116
 
    else:
117
 
        F = os.path.abspath
118
 
    [p,e] = os.path.split(f)
119
 
    if e == "" or e == "." or e == "..":
120
 
        return F(f)
121
 
    else:
122
 
        return os.path.join(F(p), e)
123
 
    
124
 
 
125
 
def backup_file(fn):
126
 
    """Copy a file to a backup.
127
 
 
128
 
    Backups are named in GNU-style, with a ~ suffix.
129
 
 
130
 
    If the file is already a backup, it's not copied.
131
 
    """
132
 
    if fn[-1] == '~':
133
 
        return
134
 
    bfn = fn + '~'
135
 
 
136
 
    if has_symlinks() and os.path.islink(fn):
137
 
        target = os.readlink(fn)
138
 
        os.symlink(target, bfn)
139
 
        return
140
 
    inf = file(fn, 'rb')
141
 
    try:
142
 
        content = inf.read()
143
 
    finally:
144
 
        inf.close()
145
 
    
146
 
    outf = file(bfn, 'wb')
147
 
    try:
148
 
        outf.write(content)
149
 
    finally:
150
 
        outf.close()
151
 
 
152
 
if os.name == 'nt':
153
 
    import shutil
154
 
    rename = shutil.move
155
 
else:
156
 
    rename = os.rename
157
72
 
158
73
 
159
74
def isdir(f):
164
79
        return False
165
80
 
166
81
 
 
82
 
167
83
def isfile(f):
168
84
    """True if f is a regular file."""
169
85
    try:
171
87
    except OSError:
172
88
        return False
173
89
 
174
 
def islink(f):
175
 
    """True if f is a symlink."""
176
 
    try:
177
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
178
 
    except OSError:
179
 
        return False
180
90
 
181
91
def is_inside(dir, fname):
182
92
    """True if fname is inside dir.
183
 
    
184
 
    The parameters should typically be passed to os.path.normpath first, so
185
 
    that . and .. and repeated slashes are eliminated, and the separators
186
 
    are canonical for the platform.
187
 
    
188
 
    The empty string as a dir name is taken as top-of-tree and matches 
189
 
    everything.
190
 
    
191
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
192
 
    True
193
 
    >>> is_inside('src', 'srccontrol')
194
 
    False
195
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
196
 
    True
197
 
    >>> is_inside('foo.c', 'foo.c')
198
 
    True
199
 
    >>> is_inside('foo.c', '')
200
 
    False
201
 
    >>> is_inside('', 'foo.c')
202
 
    True
203
93
    """
204
 
    # XXX: Most callers of this can actually do something smarter by 
205
 
    # looking at the inventory
206
 
    if dir == fname:
207
 
        return True
208
 
    
209
 
    if dir == '':
210
 
        return True
211
 
 
212
 
    if dir[-1] != os.sep:
213
 
        dir += os.sep
214
 
 
215
 
    return fname.startswith(dir)
 
94
    return os.path.commonprefix([dir, fname]) == dir
216
95
 
217
96
 
218
97
def is_inside_any(dir_list, fname):
219
98
    """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
    
220
103
    for dirname in dir_list:
221
104
        if is_inside(dirname, fname):
222
105
            return True
229
112
    tofile.write(fromfile.read())
230
113
 
231
114
 
 
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
 
232
123
def sha_file(f):
 
124
    import sha
233
125
    if hasattr(f, 'tell'):
234
126
        assert f.tell() == 0
235
127
    s = sha.new()
242
134
    return s.hexdigest()
243
135
 
244
136
 
245
 
 
246
 
def sha_strings(strings):
247
 
    """Return the sha-1 of concatenation of strings"""
248
 
    s = sha.new()
249
 
    map(s.update, strings)
250
 
    return s.hexdigest()
251
 
 
252
 
 
253
137
def sha_string(f):
 
138
    import sha
254
139
    s = sha.new()
255
140
    s.update(f)
256
141
    return s.hexdigest()
257
142
 
258
143
 
 
144
 
259
145
def fingerprint_file(f):
 
146
    import sha
260
147
    s = sha.new()
261
148
    b = f.read()
262
149
    s.update(b)
265
152
            'sha1': s.hexdigest()}
266
153
 
267
154
 
 
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
 
268
258
def compare_files(a, b):
269
259
    """Returns true if equal in contents"""
270
260
    BUFSIZE = 4096
277
267
            return True
278
268
 
279
269
 
 
270
 
280
271
def local_time_offset(t=None):
281
272
    """Return offset of local zone from GMT, either at present or at time t."""
282
273
    # python2.3 localtime() can't take None
305
296
        tt = time.localtime(t)
306
297
        offset = local_time_offset(t)
307
298
    else:
308
 
        raise BzrError("unsupported timezone format %r" % timezone,
309
 
                       ['options are "utc", "original", "local"'])
 
299
        bailout("unsupported timezone format %r",
 
300
                ['options are "utc", "original", "local"'])
310
301
 
311
302
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
312
303
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
321
312
    """Return size of given open file."""
322
313
    return os.fstat(f.fileno())[ST_SIZE]
323
314
 
324
 
# Define rand_bytes based on platform.
325
 
try:
326
 
    # Python 2.4 and later have os.urandom,
327
 
    # but it doesn't work on some arches
328
 
    os.urandom(1)
 
315
 
 
316
if hasattr(os, 'urandom'): # python 2.4 and later
329
317
    rand_bytes = os.urandom
330
 
except (NotImplementedError, AttributeError):
331
 
    # If python doesn't have os.urandom, or it doesn't work,
332
 
    # then try to first pull random data from /dev/urandom
333
 
    if os.path.exists("/dev/urandom"):
334
 
        rand_bytes = file('/dev/urandom', 'rb').read
335
 
    # Otherwise, use this hack as a last resort
336
 
    else:
337
 
        # not well seeded, but better than nothing
338
 
        def rand_bytes(n):
339
 
            import random
340
 
            s = ''
341
 
            while n:
342
 
                s += chr(random.randint(0, 255))
343
 
                n -= 1
344
 
            return s
 
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
 
345
330
 
346
331
## TODO: We could later have path objects that remember their list
347
332
## decomposition (might be too tricksy though.)
360
345
    >>> splitpath('a/../b')
361
346
    Traceback (most recent call last):
362
347
    ...
363
 
    BzrError: sorry, '..' not allowed in path
 
348
    BzrError: ("sorry, '..' not allowed in path", [])
364
349
    """
365
350
    assert isinstance(p, types.StringTypes)
366
351
 
371
356
    rps = []
372
357
    for f in ps:
373
358
        if f == '..':
374
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
359
            bailout("sorry, %r not allowed in path" % f)
375
360
        elif (f == '.') or (f == ''):
376
361
            pass
377
362
        else:
382
367
    assert isinstance(p, list)
383
368
    for f in p:
384
369
        if (f == '..') or (f == None) or (f == ''):
385
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
370
            bailout("sorry, %r not allowed in path" % f)
386
371
    return os.path.join(*p)
387
372
 
388
373
 
393
378
        return os.path.join(p1, p2)
394
379
    
395
380
 
396
 
def split_lines(s):
397
 
    """Split s into lines, but without removing the newline characters."""
398
 
    return StringIO(s).readlines()
399
 
 
400
 
 
401
 
def hardlinks_good():
402
 
    return sys.platform not in ('win32', 'cygwin', 'darwin')
403
 
 
404
 
 
405
 
def link_or_copy(src, dest):
406
 
    """Hardlink a file, or copy it if it can't be hardlinked."""
407
 
    if not hardlinks_good():
408
 
        copyfile(src, dest)
409
 
        return
410
 
    try:
411
 
        os.link(src, dest)
412
 
    except (OSError, IOError), e:
413
 
        if e.errno != errno.EXDEV:
414
 
            raise
415
 
        copyfile(src, dest)
416
 
 
417
 
 
418
 
def has_symlinks():
419
 
    if hasattr(os, 'symlink'):
420
 
        return True
421
 
    else:
422
 
        return False
423
 
        
424
 
 
425
 
def contains_whitespace(s):
426
 
    """True if there are any whitespace characters in s."""
427
 
    for ch in string.whitespace:
428
 
        if ch in s:
429
 
            return True
430
 
    else:
431
 
        return False
432
 
 
433
 
 
434
 
def contains_linebreaks(s):
435
 
    """True if there is any vertical whitespace in s."""
436
 
    for ch in '\f\n\r':
437
 
        if ch in s:
438
 
            return True
439
 
    else:
440
 
        return False
 
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