~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2005-05-03 08:00:27 UTC
  • Revision ID: mbp@sourcefrog.net-20050503080027-908edb5b39982198
doc

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 sys
28
 
import time
29
 
import types
 
19
import os, types, re, time, errno
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
30
21
 
 
22
from errors import bailout, BzrError
 
23
from trace import mutter
31
24
import bzrlib
32
 
from bzrlib.errors import BzrError
33
 
from bzrlib.trace import mutter
34
 
 
35
25
 
36
26
def make_readonly(filename):
37
27
    """Make a filename read-only."""
 
28
    # TODO: probably needs to be fixed for windows
38
29
    mod = os.stat(filename).st_mode
39
30
    mod = mod & 0777555
40
31
    os.chmod(filename, mod)
46
37
    os.chmod(filename, mod)
47
38
 
48
39
 
49
 
_QUOTE_RE = None
50
 
 
51
 
 
 
40
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
52
41
def quotefn(f):
53
 
    """Return a quoted filename filename
54
 
 
55
 
    This previously used backslash quoting, but that works poorly on
56
 
    Windows."""
57
 
    # TODO: I'm not really sure this is the best format either.x
58
 
    global _QUOTE_RE
59
 
    if _QUOTE_RE == None:
60
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
61
 
        
62
 
    if _QUOTE_RE.search(f):
63
 
        return '"' + f + '"'
64
 
    else:
65
 
        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
66
48
 
67
49
 
68
50
def file_kind(f):
73
55
        return 'directory'
74
56
    elif S_ISLNK(mode):
75
57
        return 'symlink'
76
 
    elif S_ISCHR(mode):
77
 
        return 'chardev'
78
 
    elif S_ISBLK(mode):
79
 
        return 'block'
80
 
    elif S_ISFIFO(mode):
81
 
        return 'fifo'
82
 
    elif S_ISSOCK(mode):
83
 
        return 'socket'
84
 
    else:
85
 
        return 'unknown'
86
 
 
87
 
 
88
 
def kind_marker(kind):
89
 
    if kind == 'file':
90
 
        return ''
91
 
    elif kind == 'directory':
92
 
        return '/'
93
 
    elif kind == 'symlink':
94
 
        return '@'
95
 
    else:
96
 
        raise BzrError('invalid file kind %r' % kind)
97
 
 
98
 
 
99
 
def backup_file(fn):
100
 
    """Copy a file to a backup.
101
 
 
102
 
    Backups are named in GNU-style, with a ~ suffix.
103
 
 
104
 
    If the file is already a backup, it's not copied.
105
 
    """
106
 
    if fn[-1] == '~':
107
 
        return
108
 
    bfn = fn + '~'
109
 
 
110
 
    inf = file(fn, 'rb')
111
 
    try:
112
 
        content = inf.read()
113
 
    finally:
114
 
        inf.close()
115
 
    
116
 
    outf = file(bfn, 'wb')
117
 
    try:
118
 
        outf.write(content)
119
 
    finally:
120
 
        outf.close()
121
 
 
122
 
if os.name == 'nt':
123
 
    import shutil
124
 
    rename = shutil.move
125
 
else:
126
 
    rename = os.rename
 
58
    else:
 
59
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f)) 
 
60
 
127
61
 
128
62
 
129
63
def isdir(f):
134
68
        return False
135
69
 
136
70
 
 
71
 
137
72
def isfile(f):
138
73
    """True if f is a regular file."""
139
74
    try:
142
77
        return False
143
78
 
144
79
 
145
 
def is_inside(dir, fname):
146
 
    """True if fname is inside dir.
147
 
    
148
 
    The parameters should typically be passed to os.path.normpath first, so
149
 
    that . and .. and repeated slashes are eliminated, and the separators
150
 
    are canonical for the platform.
151
 
    
152
 
    The empty string as a dir name is taken as top-of-tree and matches 
153
 
    everything.
154
 
    
155
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
156
 
    True
157
 
    >>> is_inside('src', 'srccontrol')
158
 
    False
159
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
160
 
    True
161
 
    >>> is_inside('foo.c', 'foo.c')
162
 
    True
163
 
    >>> is_inside('foo.c', '')
164
 
    False
165
 
    >>> is_inside('', 'foo.c')
166
 
    True
167
 
    """
168
 
    # XXX: Most callers of this can actually do something smarter by 
169
 
    # looking at the inventory
170
 
    if dir == fname:
171
 
        return True
172
 
    
173
 
    if dir == '':
174
 
        return True
175
 
 
176
 
    if dir[-1] != os.sep:
177
 
        dir += os.sep
178
 
 
179
 
    return fname.startswith(dir)
180
 
 
181
 
 
182
 
def is_inside_any(dir_list, fname):
183
 
    """True if fname is inside any of given dirs."""
184
 
    for dirname in dir_list:
185
 
        if is_inside(dirname, fname):
186
 
            return True
187
 
    else:
188
 
        return False
189
 
 
190
 
 
191
80
def pumpfile(fromfile, tofile):
192
81
    """Copy contents of one file to another."""
193
82
    tofile.write(fromfile.read())
194
83
 
195
84
 
 
85
def uuid():
 
86
    """Return a new UUID"""
 
87
    try:
 
88
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
89
    except IOError:
 
90
        return chomp(os.popen('uuidgen').readline())
 
91
 
 
92
 
196
93
def sha_file(f):
 
94
    import sha
197
95
    if hasattr(f, 'tell'):
198
96
        assert f.tell() == 0
199
97
    s = sha.new()
206
104
    return s.hexdigest()
207
105
 
208
106
 
209
 
 
210
 
def sha_strings(strings):
211
 
    """Return the sha-1 of concatenation of strings"""
212
 
    s = sha.new()
213
 
    map(s.update, strings)
214
 
    return s.hexdigest()
215
 
 
216
 
 
217
107
def sha_string(f):
 
108
    import sha
218
109
    s = sha.new()
219
110
    s.update(f)
220
111
    return s.hexdigest()
221
112
 
222
113
 
 
114
 
223
115
def fingerprint_file(f):
 
116
    import sha
224
117
    s = sha.new()
225
118
    b = f.read()
226
119
    s.update(b)
236
129
    
237
130
    TODO: Global option --config-dir to override this.
238
131
    """
239
 
    return os.path.join(os.path.expanduser("~"), ".bzr.conf")
 
132
    return os.path.expanduser("~/.bzr.conf")
240
133
 
241
134
 
242
135
def _auto_user_id():
275
168
    return realname, (username + '@' + socket.gethostname())
276
169
 
277
170
 
278
 
def _get_user_id(branch):
 
171
def _get_user_id():
279
172
    """Return the full user id from a file or environment variable.
280
173
 
281
 
    e.g. "John Hacker <jhacker@foo.org>"
282
 
 
283
 
    branch
284
 
        A branch to use for a per-branch configuration, or None.
285
 
 
286
 
    The following are searched in order:
287
 
 
288
 
    1. $BZREMAIL
289
 
    2. .bzr/email for this branch.
290
 
    3. ~/.bzr.conf/email
291
 
    4. $EMAIL
292
 
    """
 
174
    TODO: Allow taking this from a file in the branch directory too
 
175
    for per-branch ids."""
293
176
    v = os.environ.get('BZREMAIL')
294
177
    if v:
295
178
        return v.decode(bzrlib.user_encoding)
296
 
 
297
 
    if branch:
298
 
        try:
299
 
            return (branch.controlfile("email", "r") 
300
 
                    .read()
301
 
                    .decode(bzrlib.user_encoding)
302
 
                    .rstrip("\r\n"))
303
 
        except IOError, e:
304
 
            if e.errno != errno.ENOENT:
305
 
                raise
306
 
        except BzrError, e:
307
 
            pass
308
179
    
309
180
    try:
310
181
        return (open(os.path.join(config_dir(), "email"))
322
193
        return None
323
194
 
324
195
 
325
 
def username(branch):
 
196
def username():
326
197
    """Return email-style username.
327
198
 
328
199
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
329
200
 
330
201
    TODO: Check it's reasonably well-formed.
331
202
    """
332
 
    v = _get_user_id(branch)
 
203
    v = _get_user_id()
333
204
    if v:
334
205
        return v
335
206
    
340
211
        return email
341
212
 
342
213
 
343
 
def user_email(branch):
 
214
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
 
215
def user_email():
344
216
    """Return just the email component of a username."""
345
 
    e = _get_user_id(branch)
 
217
    e = _get_user_id()
346
218
    if e:
347
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
219
        m = _EMAIL_RE.search(e)
348
220
        if not m:
349
 
            raise BzrError("%r doesn't seem to contain "
350
 
                           "a reasonable email address" % e)
 
221
            bailout("%r doesn't seem to contain a reasonable email address" % e)
351
222
        return m.group(0)
352
223
 
353
224
    return _auto_user_id()[1]
 
225
    
354
226
 
355
227
 
356
228
def compare_files(a, b):
365
237
            return True
366
238
 
367
239
 
 
240
 
368
241
def local_time_offset(t=None):
369
242
    """Return offset of local zone from GMT, either at present or at time t."""
370
243
    # python2.3 localtime() can't take None
393
266
        tt = time.localtime(t)
394
267
        offset = local_time_offset(t)
395
268
    else:
396
 
        raise BzrError("unsupported timezone format %r" % timezone,
397
 
                       ['options are "utc", "original", "local"'])
 
269
        bailout("unsupported timezone format %r",
 
270
                ['options are "utc", "original", "local"'])
398
271
 
399
272
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
400
273
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
409
282
    """Return size of given open file."""
410
283
    return os.fstat(f.fileno())[ST_SIZE]
411
284
 
412
 
# Define rand_bytes based on platform.
413
 
try:
414
 
    # Python 2.4 and later have os.urandom,
415
 
    # but it doesn't work on some arches
416
 
    os.urandom(1)
 
285
 
 
286
if hasattr(os, 'urandom'): # python 2.4 and later
417
287
    rand_bytes = os.urandom
418
 
except (NotImplementedError, AttributeError):
419
 
    # If python doesn't have os.urandom, or it doesn't work,
420
 
    # then try to first pull random data from /dev/urandom
421
 
    if os.path.exists("/dev/urandom"):
422
 
        rand_bytes = file('/dev/urandom', 'rb').read
423
 
    # Otherwise, use this hack as a last resort
424
 
    else:
425
 
        # not well seeded, but better than nothing
426
 
        def rand_bytes(n):
427
 
            import random
428
 
            s = ''
429
 
            while n:
430
 
                s += chr(random.randint(0, 255))
431
 
                n -= 1
432
 
            return s
 
288
else:
 
289
    # FIXME: No good on non-Linux
 
290
    _rand_file = file('/dev/urandom', 'rb')
 
291
    rand_bytes = _rand_file.read
 
292
 
433
293
 
434
294
## TODO: We could later have path objects that remember their list
435
295
## decomposition (might be too tricksy though.)
448
308
    >>> splitpath('a/../b')
449
309
    Traceback (most recent call last):
450
310
    ...
451
 
    BzrError: sorry, '..' not allowed in path
 
311
    BzrError: ("sorry, '..' not allowed in path", [])
452
312
    """
453
313
    assert isinstance(p, types.StringTypes)
454
314
 
459
319
    rps = []
460
320
    for f in ps:
461
321
        if f == '..':
462
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
322
            bailout("sorry, %r not allowed in path" % f)
463
323
        elif (f == '.') or (f == ''):
464
324
            pass
465
325
        else:
470
330
    assert isinstance(p, list)
471
331
    for f in p:
472
332
        if (f == '..') or (f == None) or (f == ''):
473
 
            raise BzrError("sorry, %r not allowed in path" % f)
 
333
            bailout("sorry, %r not allowed in path" % f)
474
334
    return os.path.join(*p)
475
335
 
476
336
 
481
341
        return os.path.join(p1, p2)
482
342
    
483
343
 
484
 
def _read_config_value(name):
485
 
    """Read a config value from the file ~/.bzr.conf/<name>
486
 
    Return None if the file does not exist"""
487
 
    try:
488
 
        f = file(os.path.join(config_dir(), name), "r")
489
 
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
490
 
    except IOError, e:
491
 
        if e.errno == errno.ENOENT:
492
 
            return None
493
 
        raise
494
 
 
495
 
 
496
 
def split_lines(s):
497
 
    """Split s into lines, but without removing the newline characters."""
498
 
    return StringIO(s).readlines()
499
 
 
500
 
 
501
 
def hardlinks_good():
502
 
    return sys.platform not in ('win32', 'cygwin', 'darwin')
503
 
 
504
 
 
505
 
def link_or_copy(src, dest):
506
 
    """Hardlink a file, or copy it if it can't be hardlinked."""
507
 
    if not hardlinks_good():
508
 
        copyfile(src, dest)
509
 
        return
510
 
    try:
511
 
        os.link(src, dest)
512
 
    except (OSError, IOError), e:
513
 
        if e.errno != errno.EXDEV:
514
 
            raise
515
 
        copyfile(src, dest)
 
344
def extern_command(cmd, ignore_errors = False):
 
345
    mutter('external command: %s' % `cmd`)
 
346
    if os.system(cmd):
 
347
        if not ignore_errors:
 
348
            bailout('command failed')
 
349