← 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-29 13:40:25 UTC
  • Revision ID: mbp@sourcefrog.net-20050729134025-9abbcae0d0faf25f
- todo: discussion of an uncommit command

  and this is the thousandth revision! :-)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
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, ST_MODE, ST_SIZE
 
19
import os, types, re, time, errno, sys
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
21
21
 
22
 
from errors import bailout
 
22
from bzrlib.errors import BzrError
 
23
from bzrlib.trace import mutter
 
24
import bzrlib
23
25
 
24
26
def make_readonly(filename):
25
27
    """Make a filename read-only."""
36
38
 
37
39
 
38
40
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
41
 
 
42
_SLASH_RE = re.compile(r'[\\/]+')
 
43
 
39
44
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
 
45
    """Return a quoted filename filename
 
46
 
 
47
    This previously used backslash quoting, but that works poorly on
 
48
    Windows."""
 
49
    # TODO: I'm not really sure this is the best format either.x
 
50
    if _QUOTE_RE.search(f):
 
51
        return '"' + f + '"'
 
52
    else:
 
53
        return f
46
54
 
47
55
 
48
56
def file_kind(f):
51
59
        return 'file'
52
60
    elif S_ISDIR(mode):
53
61
        return 'directory'
54
 
    else:
55
 
        bailout("can't handle file kind of %r" % fp)
 
62
    elif S_ISLNK(mode):
 
63
        return 'symlink'
 
64
    else:
 
65
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
 
66
 
 
67
 
 
68
def kind_marker(kind):
 
69
    if kind == 'file':
 
70
        return ''
 
71
    elif kind == 'directory':
 
72
        return '/'
 
73
    elif kind == 'symlink':
 
74
        return '@'
 
75
    else:
 
76
        raise BzrError('invalid file kind %r' % kind)
 
77
 
 
78
 
 
79
 
 
80
def backup_file(fn):
 
81
    """Copy a file to a backup.
 
82
 
 
83
    Backups are named in GNU-style, with a ~ suffix.
 
84
 
 
85
    If the file is already a backup, it's not copied.
 
86
    """
 
87
    import os
 
88
    if fn[-1] == '~':
 
89
        return
 
90
    bfn = fn + '~'
 
91
 
 
92
    inf = file(fn, 'rb')
 
93
    try:
 
94
        content = inf.read()
 
95
    finally:
 
96
        inf.close()
 
97
    
 
98
    outf = file(bfn, 'wb')
 
99
    try:
 
100
        outf.write(content)
 
101
    finally:
 
102
        outf.close()
 
103
 
 
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
 
56
115
 
57
116
 
58
117
 
73
132
        return False
74
133
 
75
134
 
 
135
def is_inside(dir, fname):
 
136
    """True if fname is inside dir.
 
137
    
 
138
    The parameters should typically be passed to os.path.normpath first, so
 
139
    that . and .. and repeated slashes are eliminated, and the separators
 
140
    are canonical for the platform.
 
141
    
 
142
    The empty string as a dir name is taken as top-of-tree and matches 
 
143
    everything.
 
144
    
 
145
    >>> is_inside('src', 'src/foo.c')
 
146
    True
 
147
    >>> is_inside('src', 'srccontrol')
 
148
    False
 
149
    >>> is_inside('src', 'src/a/a/a/foo.c')
 
150
    True
 
151
    >>> is_inside('foo.c', 'foo.c')
 
152
    True
 
153
    >>> is_inside('foo.c', '')
 
154
    False
 
155
    >>> is_inside('', 'foo.c')
 
156
    True
 
157
    """
 
158
    # XXX: Most callers of this can actually do something smarter by 
 
159
    # looking at the inventory
 
160
    if dir == fname:
 
161
        return True
 
162
    
 
163
    if dir == '':
 
164
        return True
 
165
    
 
166
    if dir[-1] != os.sep:
 
167
        dir += os.sep
 
168
    
 
169
    return fname.startswith(dir)
 
170
 
 
171
 
 
172
def is_inside_any(dir_list, fname):
 
173
    """True if fname is inside any of given dirs."""
 
174
    for dirname in dir_list:
 
175
        if is_inside(dirname, fname):
 
176
            return True
 
177
    else:
 
178
        return False
 
179
 
 
180
 
76
181
def pumpfile(fromfile, tofile):
77
182
    """Copy contents of one file to another."""
78
183
    tofile.write(fromfile.read())
80
185
 
81
186
def uuid():
82
187
    """Return a new UUID"""
83
 
    
84
 
    ## XXX: Could alternatively read /proc/sys/kernel/random/uuid on
85
 
    ## Linux, but we need something portable for other systems;
86
 
    ## preferably an implementation in Python.
87
 
    bailout('uuids not allowed!')
88
 
    return chomp(os.popen('uuidgen').readline())
89
 
 
90
 
def chomp(s):
91
 
    if s and (s[-1] == '\n'):
92
 
        return s[:-1]
93
 
    else:
94
 
        return s
 
188
    try:
 
189
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
190
    except IOError:
 
191
        return chomp(os.popen('uuidgen').readline())
95
192
 
96
193
 
97
194
def sha_file(f):
98
195
    import sha
99
 
    ## TODO: Maybe read in chunks to handle big files
100
196
    if hasattr(f, 'tell'):
101
197
        assert f.tell() == 0
102
198
    s = sha.new()
103
 
    s.update(f.read())
 
199
    BUFSIZE = 128<<10
 
200
    while True:
 
201
        b = f.read(BUFSIZE)
 
202
        if not b:
 
203
            break
 
204
        s.update(b)
104
205
    return s.hexdigest()
105
206
 
106
207
 
112
213
 
113
214
 
114
215
 
115
 
def username():
116
 
    """Return email-style username.
117
 
 
118
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
119
 
 
120
 
    :todo: Check it's reasonably well-formed.
121
 
 
122
 
    :todo: Allow taking it from a dotfile to help people on windows
123
 
           who can't easily set variables.
124
 
 
125
 
    :todo: Cope without pwd module, which is only on unix. 
126
 
    """
127
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
128
 
    if e: return e
129
 
 
 
216
def fingerprint_file(f):
 
217
    import sha
 
218
    s = sha.new()
 
219
    b = f.read()
 
220
    s.update(b)
 
221
    size = len(b)
 
222
    return {'size': size,
 
223
            'sha1': s.hexdigest()}
 
224
 
 
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
    """
130
247
    import socket
131
 
    
 
248
 
 
249
    # XXX: Any good way to get real user name on win32?
 
250
 
132
251
    try:
133
252
        import pwd
134
253
        uid = os.getuid()
135
254
        w = pwd.getpwuid(uid)
136
 
        realname, junk = w.pw_gecos.split(',', 1)
137
 
        return '%s <%s@%s>' % (realname, w.pw_name, socket.getfqdn())
 
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
 
138
265
    except ImportError:
139
 
        pass
140
 
 
141
 
    import getpass, socket
142
 
    return '<%s@%s>' % (getpass.getuser(), socket.getfqdn())
143
 
 
144
 
 
 
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+.-]+')
145
316
def user_email():
146
317
    """Return just the email component of a username."""
147
 
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
 
318
    e = _get_user_id()
148
319
    if e:
149
 
        import re
150
 
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
320
        m = _EMAIL_RE.search(e)
151
321
        if not m:
152
 
            bailout('%r is not a reasonable email address' % e)
 
322
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
153
323
        return m.group(0)
154
324
 
155
 
 
156
 
    import getpass, socket
157
 
    return '%s@%s' % (getpass.getuser(), socket.getfqdn())
158
 
 
 
325
    return _auto_user_id()[1]
159
326
    
160
327
 
161
328
 
162
329
def compare_files(a, b):
163
330
    """Returns true if equal in contents"""
164
 
    # TODO: don't read the whole thing in one go.
165
 
    result = a.read() == b.read()
166
 
    return result
167
 
 
168
 
 
169
 
 
170
 
def local_time_offset():
171
 
    if time.daylight:
 
331
    BUFSIZE = 4096
 
332
    while True:
 
333
        ai = a.read(BUFSIZE)
 
334
        bi = b.read(BUFSIZE)
 
335
        if ai != bi:
 
336
            return False
 
337
        if ai == '':
 
338
            return True
 
339
 
 
340
 
 
341
 
 
342
def local_time_offset(t=None):
 
343
    """Return offset of local zone from GMT, either at present or at time t."""
 
344
    # python2.3 localtime() can't take None
 
345
    if t == None:
 
346
        t = time.time()
 
347
        
 
348
    if time.localtime(t).tm_isdst and time.daylight:
172
349
        return -time.altzone
173
350
    else:
174
351
        return -time.timezone
177
354
def format_date(t, offset=0, timezone='original'):
178
355
    ## TODO: Perhaps a global option to use either universal or local time?
179
356
    ## Or perhaps just let people set $TZ?
180
 
    import time
181
 
    
182
357
    assert isinstance(t, float)
183
358
    
184
359
    if timezone == 'utc':
185
360
        tt = time.gmtime(t)
186
361
        offset = 0
187
362
    elif timezone == 'original':
188
 
        tt = time.gmtime(t - offset)
 
363
        if offset == None:
 
364
            offset = 0
 
365
        tt = time.gmtime(t + offset)
189
366
    elif timezone == 'local':
190
367
        tt = time.localtime(t)
191
 
        offset = local_time_offset()
 
368
        offset = local_time_offset(t)
192
369
    else:
193
 
        bailout("unsupported timezone format %r",
194
 
                ['options are "utc", "original", "local"'])
 
370
        raise BzrError("unsupported timezone format %r" % timezone,
 
371
                       ['options are "utc", "original", "local"'])
195
372
 
196
373
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
197
374
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
209
386
 
210
387
if hasattr(os, 'urandom'): # python 2.4 and later
211
388
    rand_bytes = os.urandom
 
389
elif sys.platform == 'linux2':
 
390
    rand_bytes = file('/dev/urandom', 'rb').read
212
391
else:
213
 
    # FIXME: No good on non-Linux
214
 
    _rand_file = file('/dev/urandom', 'rb')
215
 
    rand_bytes = _rand_file.read
 
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
216
400
 
217
401
 
218
402
## TODO: We could later have path objects that remember their list
232
416
    >>> splitpath('a/../b')
233
417
    Traceback (most recent call last):
234
418
    ...
235
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
419
    BzrError: sorry, '..' not allowed in path
236
420
    """
237
421
    assert isinstance(p, types.StringTypes)
238
 
    ps = [f for f in p.split('/') if f != '.']
 
422
 
 
423
    # split on either delimiter because people might use either on
 
424
    # Windows
 
425
    ps = re.split(r'[\\/]', p)
 
426
 
 
427
    rps = []
239
428
    for f in ps:
240
429
        if f == '..':
241
 
            bailout("sorry, %r not allowed in path" % f)
242
 
    return ps
 
430
            raise BzrError("sorry, %r not allowed in path" % f)
 
431
        elif (f == '.') or (f == ''):
 
432
            pass
 
433
        else:
 
434
            rps.append(f)
 
435
    return rps
243
436
 
244
437
def joinpath(p):
245
438
    assert isinstance(p, list)
246
439
    for f in p:
247
 
        if (f == '..') or (f is None) or (f == ''):
248
 
            bailout("sorry, %r not allowed in path" % f)
249
 
    return '/'.join(p)
 
440
        if (f == '..') or (f == None) or (f == ''):
 
441
            raise BzrError("sorry, %r not allowed in path" % f)
 
442
    return os.path.join(*p)
250
443
 
251
444
 
252
445
def appendpath(p1, p2):
253
446
    if p1 == '':
254
447
        return p2
255
448
    else:
256
 
        return p1 + '/' + p2
 
449
        return os.path.join(p1, p2)
257
450
    
258
451
 
259
452
def extern_command(cmd, ignore_errors = False):
260
453
    mutter('external command: %s' % `cmd`)
261
454
    if os.system(cmd):
262
455
        if not ignore_errors:
263
 
            bailout('command failed')
264
 
 
 
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