← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2005-07-22 23:32:00 UTC
  • Revision ID: mbp@sourcefrog.net-20050722233200-ccdeca985093a9fb
- now needs python 2.4
- update instructions for running selftest

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
 
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
 
32
 
import bzrlib
33
 
from bzrlib.config import config_dir, _get_user_id
34
22
from bzrlib.errors import BzrError
35
23
from bzrlib.trace import mutter
36
 
 
 
24
import bzrlib
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
42
    """Return a quoted filename filename
56
43
 
57
44
    This previously used backslash quoting, but that works poorly on
58
45
    Windows."""
59
46
    # 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
47
    if _QUOTE_RE.search(f):
65
48
        return '"' + f + '"'
66
49
    else:
75
58
        return 'directory'
76
59
    elif S_ISLNK(mode):
77
60
        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
61
    else:
87
 
        return 'unknown'
 
62
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
88
63
 
89
64
 
90
65
def kind_marker(kind):
97
72
    else:
98
73
        raise BzrError('invalid file kind %r' % kind)
99
74
 
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
75
 
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
76
 
125
77
def backup_file(fn):
126
78
    """Copy a file to a backup.
129
81
 
130
82
    If the file is already a backup, it's not copied.
131
83
    """
 
84
    import os
132
85
    if fn[-1] == '~':
133
86
        return
134
87
    bfn = fn + '~'
135
88
 
136
 
    if has_symlinks() and os.path.islink(fn):
137
 
        target = os.readlink(fn)
138
 
        os.symlink(target, bfn)
139
 
        return
140
89
    inf = file(fn, 'rb')
141
90
    try:
142
91
        content = inf.read()
149
98
    finally:
150
99
        outf.close()
151
100
 
152
 
if os.name == 'nt':
153
 
    import shutil
154
 
    rename = shutil.move
155
 
else:
156
 
    rename = os.rename
 
101
def rename(path_from, path_to):
 
102
    """Basically the same as os.rename() just special for win32"""
 
103
    if sys.platform == 'win32':
 
104
        try:
 
105
            os.remove(path_to)
 
106
        except OSError, e:
 
107
            if e.errno != e.ENOENT:
 
108
                raise
 
109
    os.rename(path_from, path_to)
 
110
 
 
111
 
 
112
 
157
113
 
158
114
 
159
115
def isdir(f):
164
120
        return False
165
121
 
166
122
 
 
123
 
167
124
def isfile(f):
168
125
    """True if f is a regular file."""
169
126
    try:
171
128
    except OSError:
172
129
        return False
173
130
 
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
131
 
181
132
def is_inside(dir, fname):
182
133
    """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
134
    """
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)
 
135
    return os.path.commonprefix([dir, fname]) == dir
216
136
 
217
137
 
218
138
def is_inside_any(dir_list, fname):
219
139
    """True if fname is inside any of given dirs."""
 
140
    # quick scan for perfect match
 
141
    if fname in dir_list:
 
142
        return True
 
143
    
220
144
    for dirname in dir_list:
221
145
        if is_inside(dirname, fname):
222
146
            return True
229
153
    tofile.write(fromfile.read())
230
154
 
231
155
 
 
156
def uuid():
 
157
    """Return a new UUID"""
 
158
    try:
 
159
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
160
    except IOError:
 
161
        return chomp(os.popen('uuidgen').readline())
 
162
 
 
163
 
232
164
def sha_file(f):
 
165
    import sha
233
166
    if hasattr(f, 'tell'):
234
167
        assert f.tell() == 0
235
168
    s = sha.new()
242
175
    return s.hexdigest()
243
176
 
244
177
 
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
178
def sha_string(f):
 
179
    import sha
254
180
    s = sha.new()
255
181
    s.update(f)
256
182
    return s.hexdigest()
257
183
 
258
184
 
 
185
 
259
186
def fingerprint_file(f):
 
187
    import sha
260
188
    s = sha.new()
261
189
    b = f.read()
262
190
    s.update(b)
265
193
            'sha1': s.hexdigest()}
266
194
 
267
195
 
 
196
def config_dir():
 
197
    """Return per-user configuration directory.
 
198
 
 
199
    By default this is ~/.bzr.conf/
 
200
    
 
201
    TODO: Global option --config-dir to override this.
 
202
    """
 
203
    return os.path.expanduser("~/.bzr.conf")
 
204
 
 
205
 
 
206
def _auto_user_id():
 
207
    """Calculate automatic user identification.
 
208
 
 
209
    Returns (realname, email).
 
210
 
 
211
    Only used when none is set in the environment or the id file.
 
212
 
 
213
    This previously used the FQDN as the default domain, but that can
 
214
    be very slow on machines where DNS is broken.  So now we simply
 
215
    use the hostname.
 
216
    """
 
217
    import socket
 
218
 
 
219
    # XXX: Any good way to get real user name on win32?
 
220
 
 
221
    try:
 
222
        import pwd
 
223
        uid = os.getuid()
 
224
        w = pwd.getpwuid(uid)
 
225
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
226
        username = w.pw_name.decode(bzrlib.user_encoding)
 
227
        comma = gecos.find(',')
 
228
        if comma == -1:
 
229
            realname = gecos
 
230
        else:
 
231
            realname = gecos[:comma]
 
232
        if not realname:
 
233
            realname = username
 
234
 
 
235
    except ImportError:
 
236
        import getpass
 
237
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
238
 
 
239
    return realname, (username + '@' + socket.gethostname())
 
240
 
 
241
 
 
242
def _get_user_id():
 
243
    """Return the full user id from a file or environment variable.
 
244
 
 
245
    TODO: Allow taking this from a file in the branch directory too
 
246
    for per-branch ids."""
 
247
    v = os.environ.get('BZREMAIL')
 
248
    if v:
 
249
        return v.decode(bzrlib.user_encoding)
 
250
    
 
251
    try:
 
252
        return (open(os.path.join(config_dir(), "email"))
 
253
                .read()
 
254
                .decode(bzrlib.user_encoding)
 
255
                .rstrip("\r\n"))
 
256
    except IOError, e:
 
257
        if e.errno != errno.ENOENT:
 
258
            raise e
 
259
 
 
260
    v = os.environ.get('EMAIL')
 
261
    if v:
 
262
        return v.decode(bzrlib.user_encoding)
 
263
    else:    
 
264
        return None
 
265
 
 
266
 
 
267
def username():
 
268
    """Return email-style username.
 
269
 
 
270
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
271
 
 
272
    TODO: Check it's reasonably well-formed.
 
273
    """
 
274
    v = _get_user_id()
 
275
    if v:
 
276
        return v
 
277
    
 
278
    name, email = _auto_user_id()
 
279
    if name:
 
280
        return '%s <%s>' % (name, email)
 
281
    else:
 
282
        return email
 
283
 
 
284
 
 
285
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
 
286
def user_email():
 
287
    """Return just the email component of a username."""
 
288
    e = _get_user_id()
 
289
    if e:
 
290
        m = _EMAIL_RE.search(e)
 
291
        if not m:
 
292
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
 
293
        return m.group(0)
 
294
 
 
295
    return _auto_user_id()[1]
 
296
    
 
297
 
 
298
 
268
299
def compare_files(a, b):
269
300
    """Returns true if equal in contents"""
270
301
    BUFSIZE = 4096
277
308
            return True
278
309
 
279
310
 
 
311
 
280
312
def local_time_offset(t=None):
281
313
    """Return offset of local zone from GMT, either at present or at time t."""
282
314
    # python2.3 localtime() can't take None
305
337
        tt = time.localtime(t)
306
338
        offset = local_time_offset(t)
307
339
    else:
308
 
        raise BzrError("unsupported timezone format %r" % timezone,
309
 
                       ['options are "utc", "original", "local"'])
 
340
        raise BzrError("unsupported timezone format %r",
 
341
                ['options are "utc", "original", "local"'])
310
342
 
311
343
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
312
344
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
321
353
    """Return size of given open file."""
322
354
    return os.fstat(f.fileno())[ST_SIZE]
323
355
 
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)
 
356
 
 
357
if hasattr(os, 'urandom'): # python 2.4 and later
329
358
    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
 
359
elif sys.platform == 'linux2':
 
360
    rand_bytes = file('/dev/urandom', 'rb').read
 
361
else:
 
362
    # not well seeded, but better than nothing
 
363
    def rand_bytes(n):
 
364
        import random
 
365
        s = ''
 
366
        while n:
 
367
            s += chr(random.randint(0, 255))
 
368
            n -= 1
 
369
        return s
 
370
 
345
371
 
346
372
## TODO: We could later have path objects that remember their list
347
373
## decomposition (might be too tricksy though.)
393
419
        return os.path.join(p1, p2)
394
420
    
395
421
 
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
 
422
def extern_command(cmd, ignore_errors = False):
 
423
    mutter('external command: %s' % `cmd`)
 
424
    if os.system(cmd):
 
425
        if not ignore_errors:
 
426
            raise BzrError('command failed')
 
427
 
 
428
 
 
429
def _read_config_value(name):
 
430
    """Read a config value from the file ~/.bzr.conf/<name>
 
431
    Return None if the file does not exist"""
 
432
    try:
 
433
        f = file(os.path.join(config_dir(), name), "r")
 
434
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
435
    except IOError, e:
 
436
        if e.errno == errno.ENOENT:
 
437
            return None
 
438
        raise
 
439
 
 
440
 
 
441
def _get_editor():
 
442
    """Return a sequence of possible editor binaries for the current platform"""
 
443
    e = _read_config_value("editor")
 
444
    if e is not None:
 
445
        yield e
 
446
        
 
447
    if os.name == "windows":
 
448
        yield "notepad.exe"
 
449
    elif os.name == "posix":
 
450
        try:
 
451
            yield os.environ["EDITOR"]
 
452
        except KeyError:
 
453
            yield "/usr/bin/vi"
 
454
 
 
455
 
 
456
def _run_editor(filename):
 
457
    """Try to execute an editor to edit the commit message. Returns True on success,
 
458
    False on failure"""
 
459
    for e in _get_editor():
 
460
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
 
461
        if x == 0:
 
462
            return True
 
463
        elif x == 127:
 
464
            continue
 
465
        else:
 
466
            break
 
467
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
 
468
    return False
 
469
                          
 
470
 
 
471
def get_text_message(infotext, ignoreline = "default"):
 
472
    import tempfile
 
473
    
 
474
    if ignoreline == "default":
 
475
        ignoreline = "-- This line and the following will be ignored --"
 
476
        
 
477
    try:
 
478
        tmp_fileno, msgfilename = tempfile.mkstemp()
 
479
        msgfile = os.close(tmp_fileno)
 
480
        if infotext is not None and infotext != "":
 
481
            hasinfo = True
 
482
            msgfile = file(msgfilename, "w")
 
483
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
 
484
            msgfile.close()
 
485
        else:
 
486
            hasinfo = False
 
487
 
 
488
        if not _run_editor(msgfilename):
 
489
            return None
 
490
        
 
491
        started = False
 
492
        msg = []
 
493
        lastline, nlines = 0, 0
 
494
        for line in file(msgfilename, "r"):
 
495
            stripped_line = line.strip()
 
496
            # strip empty line before the log message starts
 
497
            if not started:
 
498
                if stripped_line != "":
 
499
                    started = True
 
500
                else:
 
501
                    continue
 
502
            # check for the ignore line only if there
 
503
            # is additional information at the end
 
504
            if hasinfo and stripped_line == ignoreline:
 
505
                break
 
506
            nlines += 1
 
507
            # keep track of the last line that had some content
 
508
            if stripped_line != "":
 
509
                lastline = nlines
 
510
            msg.append(line)
 
511
            
 
512
        if len(msg) == 0:
 
513
            return None
 
514
        # delete empty lines at the end
 
515
        del msg[lastline:]
 
516
        # add a newline at the end, if needed
 
517
        if not msg[-1].endswith("\n"):
 
518
            return "%s%s" % ("".join(msg), "\n")
 
519
        else:
 
520
            return "".join(msg)
 
521
    finally:
 
522
        # delete the msg file in any case
 
523
        try: os.unlink(msgfilename)
 
524
        except IOError: pass