← 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-08-12 15:41:44 UTC
  • Revision ID: mbp@sourcefrog.net-20050812154144-bc98570a78b8f633
- merge in deferred revfile work

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
 
40
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
52
41
 
 
42
_SLASH_RE = re.compile(r'[\\/]+')
53
43
 
54
44
def quotefn(f):
55
45
    """Return a quoted filename filename
57
47
    This previously used backslash quoting, but that works poorly on
58
48
    Windows."""
59
49
    # 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
50
    if _QUOTE_RE.search(f):
65
51
        return '"' + f + '"'
66
52
    else:
75
61
        return 'directory'
76
62
    elif S_ISLNK(mode):
77
63
        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
64
    else:
87
 
        return 'unknown'
 
65
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
88
66
 
89
67
 
90
68
def kind_marker(kind):
97
75
    else:
98
76
        raise BzrError('invalid file kind %r' % kind)
99
77
 
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
78
 
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
79
 
125
80
def backup_file(fn):
126
81
    """Copy a file to a backup.
129
84
 
130
85
    If the file is already a backup, it's not copied.
131
86
    """
 
87
    import os
132
88
    if fn[-1] == '~':
133
89
        return
134
90
    bfn = fn + '~'
135
91
 
136
 
    if has_symlinks() and os.path.islink(fn):
137
 
        target = os.readlink(fn)
138
 
        os.symlink(target, bfn)
139
 
        return
140
92
    inf = file(fn, 'rb')
141
93
    try:
142
94
        content = inf.read()
149
101
    finally:
150
102
        outf.close()
151
103
 
152
 
if os.name == 'nt':
153
 
    import shutil
154
 
    rename = shutil.move
155
 
else:
156
 
    rename = os.rename
 
104
def rename(path_from, path_to):
 
105
    """Basically the same as os.rename() just special for win32"""
 
106
    if sys.platform == 'win32':
 
107
        try:
 
108
            os.remove(path_to)
 
109
        except OSError, e:
 
110
            if e.errno != e.ENOENT:
 
111
                raise
 
112
    os.rename(path_from, path_to)
 
113
 
 
114
 
 
115
 
157
116
 
158
117
 
159
118
def isdir(f):
164
123
        return False
165
124
 
166
125
 
 
126
 
167
127
def isfile(f):
168
128
    """True if f is a regular file."""
169
129
    try:
171
131
    except OSError:
172
132
        return False
173
133
 
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
134
 
181
135
def is_inside(dir, fname):
182
136
    """True if fname is inside dir.
188
142
    The empty string as a dir name is taken as top-of-tree and matches 
189
143
    everything.
190
144
    
191
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
145
    >>> is_inside('src', 'src/foo.c')
192
146
    True
193
147
    >>> is_inside('src', 'srccontrol')
194
148
    False
195
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
149
    >>> is_inside('src', 'src/a/a/a/foo.c')
196
150
    True
197
151
    >>> is_inside('foo.c', 'foo.c')
198
152
    True
208
162
    
209
163
    if dir == '':
210
164
        return True
211
 
 
 
165
    
212
166
    if dir[-1] != os.sep:
213
167
        dir += os.sep
214
 
 
 
168
    
215
169
    return fname.startswith(dir)
216
170
 
217
171
 
229
183
    tofile.write(fromfile.read())
230
184
 
231
185
 
 
186
def uuid():
 
187
    """Return a new UUID"""
 
188
    try:
 
189
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
190
    except IOError:
 
191
        return chomp(os.popen('uuidgen').readline())
 
192
 
 
193
 
232
194
def sha_file(f):
 
195
    import sha
233
196
    if hasattr(f, 'tell'):
234
197
        assert f.tell() == 0
235
198
    s = sha.new()
242
205
    return s.hexdigest()
243
206
 
244
207
 
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
208
def sha_string(f):
 
209
    import sha
254
210
    s = sha.new()
255
211
    s.update(f)
256
212
    return s.hexdigest()
257
213
 
258
214
 
 
215
 
259
216
def fingerprint_file(f):
 
217
    import sha
260
218
    s = sha.new()
261
219
    b = f.read()
262
220
    s.update(b)
265
223
            'sha1': s.hexdigest()}
266
224
 
267
225
 
 
226
def config_dir():
 
227
    """Return per-user configuration directory.
 
228
 
 
229
    By default this is ~/.bzr.conf/
 
230
    
 
231
    TODO: Global option --config-dir to override this.
 
232
    """
 
233
    return os.path.expanduser("~/.bzr.conf")
 
234
 
 
235
 
 
236
def _auto_user_id():
 
237
    """Calculate automatic user identification.
 
238
 
 
239
    Returns (realname, email).
 
240
 
 
241
    Only used when none is set in the environment or the id file.
 
242
 
 
243
    This previously used the FQDN as the default domain, but that can
 
244
    be very slow on machines where DNS is broken.  So now we simply
 
245
    use the hostname.
 
246
    """
 
247
    import socket
 
248
 
 
249
    # XXX: Any good way to get real user name on win32?
 
250
 
 
251
    try:
 
252
        import pwd
 
253
        uid = os.getuid()
 
254
        w = pwd.getpwuid(uid)
 
255
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
256
        username = w.pw_name.decode(bzrlib.user_encoding)
 
257
        comma = gecos.find(',')
 
258
        if comma == -1:
 
259
            realname = gecos
 
260
        else:
 
261
            realname = gecos[:comma]
 
262
        if not realname:
 
263
            realname = username
 
264
 
 
265
    except ImportError:
 
266
        import getpass
 
267
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
268
 
 
269
    return realname, (username + '@' + socket.gethostname())
 
270
 
 
271
 
 
272
def _get_user_id():
 
273
    """Return the full user id from a file or environment variable.
 
274
 
 
275
    TODO: Allow taking this from a file in the branch directory too
 
276
    for per-branch ids."""
 
277
    v = os.environ.get('BZREMAIL')
 
278
    if v:
 
279
        return v.decode(bzrlib.user_encoding)
 
280
    
 
281
    try:
 
282
        return (open(os.path.join(config_dir(), "email"))
 
283
                .read()
 
284
                .decode(bzrlib.user_encoding)
 
285
                .rstrip("\r\n"))
 
286
    except IOError, e:
 
287
        if e.errno != errno.ENOENT:
 
288
            raise e
 
289
 
 
290
    v = os.environ.get('EMAIL')
 
291
    if v:
 
292
        return v.decode(bzrlib.user_encoding)
 
293
    else:    
 
294
        return None
 
295
 
 
296
 
 
297
def username():
 
298
    """Return email-style username.
 
299
 
 
300
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
301
 
 
302
    TODO: Check it's reasonably well-formed.
 
303
    """
 
304
    v = _get_user_id()
 
305
    if v:
 
306
        return v
 
307
    
 
308
    name, email = _auto_user_id()
 
309
    if name:
 
310
        return '%s <%s>' % (name, email)
 
311
    else:
 
312
        return email
 
313
 
 
314
 
 
315
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
 
316
def user_email():
 
317
    """Return just the email component of a username."""
 
318
    e = _get_user_id()
 
319
    if e:
 
320
        m = _EMAIL_RE.search(e)
 
321
        if not m:
 
322
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
 
323
        return m.group(0)
 
324
 
 
325
    return _auto_user_id()[1]
 
326
    
 
327
 
 
328
 
268
329
def compare_files(a, b):
269
330
    """Returns true if equal in contents"""
270
331
    BUFSIZE = 4096
277
338
            return True
278
339
 
279
340
 
 
341
 
280
342
def local_time_offset(t=None):
281
343
    """Return offset of local zone from GMT, either at present or at time t."""
282
344
    # python2.3 localtime() can't take None
321
383
    """Return size of given open file."""
322
384
    return os.fstat(f.fileno())[ST_SIZE]
323
385
 
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)
 
386
 
 
387
if hasattr(os, 'urandom'): # python 2.4 and later
329
388
    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
 
389
elif sys.platform == 'linux2':
 
390
    rand_bytes = file('/dev/urandom', 'rb').read
 
391
else:
 
392
    # not well seeded, but better than nothing
 
393
    def rand_bytes(n):
 
394
        import random
 
395
        s = ''
 
396
        while n:
 
397
            s += chr(random.randint(0, 255))
 
398
            n -= 1
 
399
        return s
 
400
 
345
401
 
346
402
## TODO: We could later have path objects that remember their list
347
403
## decomposition (might be too tricksy though.)
393
449
        return os.path.join(p1, p2)
394
450
    
395
451
 
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
 
452
def extern_command(cmd, ignore_errors = False):
 
453
    mutter('external command: %s' % `cmd`)
 
454
    if os.system(cmd):
 
455
        if not ignore_errors:
 
456
            raise BzrError('command failed')
 
457
 
 
458
 
 
459
def _read_config_value(name):
 
460
    """Read a config value from the file ~/.bzr.conf/<name>
 
461
    Return None if the file does not exist"""
 
462
    try:
 
463
        f = file(os.path.join(config_dir(), name), "r")
 
464
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
465
    except IOError, e:
 
466
        if e.errno == errno.ENOENT:
 
467
            return None
 
468
        raise
 
469
 
 
470
 
 
471
def _get_editor():
 
472
    """Return a sequence of possible editor binaries for the current platform"""
 
473
    e = _read_config_value("editor")
 
474
    if e is not None:
 
475
        yield e
 
476
        
 
477
    if os.name == "windows":
 
478
        yield "notepad.exe"
 
479
    elif os.name == "posix":
 
480
        try:
 
481
            yield os.environ["EDITOR"]
 
482
        except KeyError:
 
483
            yield "/usr/bin/vi"
 
484
 
 
485
 
 
486
def _run_editor(filename):
 
487
    """Try to execute an editor to edit the commit message. Returns True on success,
 
488
    False on failure"""
 
489
    for e in _get_editor():
 
490
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
 
491
        if x == 0:
 
492
            return True
 
493
        elif x == 127:
 
494
            continue
 
495
        else:
 
496
            break
 
497
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
 
498
    return False
 
499
                          
 
500
 
 
501
def get_text_message(infotext, ignoreline = "default"):
 
502
    import tempfile
 
503
    
 
504
    if ignoreline == "default":
 
505
        ignoreline = "-- This line and the following will be ignored --"
 
506
        
 
507
    try:
 
508
        tmp_fileno, msgfilename = tempfile.mkstemp()
 
509
        msgfile = os.close(tmp_fileno)
 
510
        if infotext is not None and infotext != "":
 
511
            hasinfo = True
 
512
            msgfile = file(msgfilename, "w")
 
513
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
 
514
            msgfile.close()
 
515
        else:
 
516
            hasinfo = False
 
517
 
 
518
        if not _run_editor(msgfilename):
 
519
            return None
 
520
        
 
521
        started = False
 
522
        msg = []
 
523
        lastline, nlines = 0, 0
 
524
        for line in file(msgfilename, "r"):
 
525
            stripped_line = line.strip()
 
526
            # strip empty line before the log message starts
 
527
            if not started:
 
528
                if stripped_line != "":
 
529
                    started = True
 
530
                else:
 
531
                    continue
 
532
            # check for the ignore line only if there
 
533
            # is additional information at the end
 
534
            if hasinfo and stripped_line == ignoreline:
 
535
                break
 
536
            nlines += 1
 
537
            # keep track of the last line that had some content
 
538
            if stripped_line != "":
 
539
                lastline = nlines
 
540
            msg.append(line)
 
541
            
 
542
        if len(msg) == 0:
 
543
            return None
 
544
        # delete empty lines at the end
 
545
        del msg[lastline:]
 
546
        # add a newline at the end, if needed
 
547
        if not msg[-1].endswith("\n"):
 
548
            return "%s%s" % ("".join(msg), "\n")
 
549
        else:
 
550
            return "".join(msg)
 
551
    finally:
 
552
        # delete the msg file in any case
 
553
        try: os.unlink(msgfilename)
 
554
        except IOError: pass