/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2005-07-23 13:53:01 UTC
  • Revision ID: mbp@sourcefrog.net-20050723135301-89015639afd2ec98
- update news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
 
1
# Bazaar-NG -- distributed version control
 
2
 
 
3
# Copyright (C) 2005 by Canonical Ltd
 
4
 
 
5
# This program is free software; you can redistribute it and/or modify
 
6
# it under the terms of the GNU General Public License as published by
 
7
# the Free Software Foundation; either version 2 of the License, or
 
8
# (at your option) any later version.
 
9
 
 
10
# This program is distributed in the hope that it will be useful,
 
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
# GNU General Public License for more details.
 
14
 
 
15
# You should have received a copy of the GNU General Public License
 
16
# along with this program; if not, write to the Free Software
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 
 
19
import os, types, re, time, errno, sys
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
21
 
 
22
from bzrlib.errors import BzrError
 
23
from bzrlib.trace import mutter
 
24
import bzrlib
 
25
 
 
26
def make_readonly(filename):
 
27
    """Make a filename read-only."""
 
28
    # TODO: probably needs to be fixed for windows
 
29
    mod = os.stat(filename).st_mode
 
30
    mod = mod & 0777555
 
31
    os.chmod(filename, mod)
 
32
 
 
33
 
 
34
def make_writable(filename):
 
35
    mod = os.stat(filename).st_mode
 
36
    mod = mod | 0200
 
37
    os.chmod(filename, mod)
 
38
 
 
39
 
 
40
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
41
 
 
42
_SLASH_RE = re.compile(r'[\\/]+')
 
43
 
 
44
def quotefn(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
 
54
 
 
55
 
 
56
def file_kind(f):
 
57
    mode = os.lstat(f)[ST_MODE]
 
58
    if S_ISREG(mode):
 
59
        return 'file'
 
60
    elif S_ISDIR(mode):
 
61
        return 'directory'
 
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
 
 
115
 
 
116
 
 
117
 
 
118
def isdir(f):
 
119
    """True if f is an accessible directory."""
 
120
    try:
 
121
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
122
    except OSError:
 
123
        return False
 
124
 
 
125
 
 
126
 
 
127
def isfile(f):
 
128
    """True if f is a regular file."""
 
129
    try:
 
130
        return S_ISREG(os.lstat(f)[ST_MODE])
 
131
    except OSError:
 
132
        return False
 
133
 
 
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
    >>> is_inside('src', 'src/foo.c')
 
143
    True
 
144
    >>> is_inside('src', 'srccontrol')
 
145
    False
 
146
    >>> is_inside('src', 'src/a/a/a/foo.c')
 
147
    True
 
148
    >>> is_inside('foo.c', 'foo.c')
 
149
    True
 
150
    """
 
151
    # XXX: Most callers of this can actually do something smarter by 
 
152
    # looking at the inventory
 
153
    
 
154
    dir = dir.split(os.sep)
 
155
    pl = len(dir)
 
156
    fname = fname.split(os.sep)
 
157
   
 
158
    return (len(fname) >= pl) and (dir == fname[:pl])
 
159
    
 
160
 
 
161
def is_inside_any(dir_list, fname):
 
162
    """True if fname is inside any of given dirs."""
 
163
    # quick scan for perfect match
 
164
    if fname in dir_list:
 
165
        return True
 
166
    
 
167
    for dirname in dir_list:
 
168
        if is_inside(dirname, fname):
 
169
            return True
 
170
    else:
 
171
        return False
 
172
 
 
173
 
 
174
def pumpfile(fromfile, tofile):
 
175
    """Copy contents of one file to another."""
 
176
    tofile.write(fromfile.read())
 
177
 
 
178
 
 
179
def uuid():
 
180
    """Return a new UUID"""
 
181
    try:
 
182
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
183
    except IOError:
 
184
        return chomp(os.popen('uuidgen').readline())
 
185
 
 
186
 
 
187
def sha_file(f):
 
188
    import sha
 
189
    if hasattr(f, 'tell'):
 
190
        assert f.tell() == 0
 
191
    s = sha.new()
 
192
    BUFSIZE = 128<<10
 
193
    while True:
 
194
        b = f.read(BUFSIZE)
 
195
        if not b:
 
196
            break
 
197
        s.update(b)
 
198
    return s.hexdigest()
 
199
 
 
200
 
 
201
def sha_string(f):
 
202
    import sha
 
203
    s = sha.new()
 
204
    s.update(f)
 
205
    return s.hexdigest()
 
206
 
 
207
 
 
208
 
 
209
def fingerprint_file(f):
 
210
    import sha
 
211
    s = sha.new()
 
212
    b = f.read()
 
213
    s.update(b)
 
214
    size = len(b)
 
215
    return {'size': size,
 
216
            'sha1': s.hexdigest()}
 
217
 
 
218
 
 
219
def config_dir():
 
220
    """Return per-user configuration directory.
 
221
 
 
222
    By default this is ~/.bzr.conf/
 
223
    
 
224
    TODO: Global option --config-dir to override this.
 
225
    """
 
226
    return os.path.expanduser("~/.bzr.conf")
 
227
 
 
228
 
 
229
def _auto_user_id():
 
230
    """Calculate automatic user identification.
 
231
 
 
232
    Returns (realname, email).
 
233
 
 
234
    Only used when none is set in the environment or the id file.
 
235
 
 
236
    This previously used the FQDN as the default domain, but that can
 
237
    be very slow on machines where DNS is broken.  So now we simply
 
238
    use the hostname.
 
239
    """
 
240
    import socket
 
241
 
 
242
    # XXX: Any good way to get real user name on win32?
 
243
 
 
244
    try:
 
245
        import pwd
 
246
        uid = os.getuid()
 
247
        w = pwd.getpwuid(uid)
 
248
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
249
        username = w.pw_name.decode(bzrlib.user_encoding)
 
250
        comma = gecos.find(',')
 
251
        if comma == -1:
 
252
            realname = gecos
 
253
        else:
 
254
            realname = gecos[:comma]
 
255
        if not realname:
 
256
            realname = username
 
257
 
 
258
    except ImportError:
 
259
        import getpass
 
260
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
261
 
 
262
    return realname, (username + '@' + socket.gethostname())
 
263
 
 
264
 
 
265
def _get_user_id():
 
266
    """Return the full user id from a file or environment variable.
 
267
 
 
268
    TODO: Allow taking this from a file in the branch directory too
 
269
    for per-branch ids."""
 
270
    v = os.environ.get('BZREMAIL')
 
271
    if v:
 
272
        return v.decode(bzrlib.user_encoding)
 
273
    
 
274
    try:
 
275
        return (open(os.path.join(config_dir(), "email"))
 
276
                .read()
 
277
                .decode(bzrlib.user_encoding)
 
278
                .rstrip("\r\n"))
 
279
    except IOError, e:
 
280
        if e.errno != errno.ENOENT:
 
281
            raise e
 
282
 
 
283
    v = os.environ.get('EMAIL')
 
284
    if v:
 
285
        return v.decode(bzrlib.user_encoding)
 
286
    else:    
 
287
        return None
 
288
 
 
289
 
 
290
def username():
 
291
    """Return email-style username.
 
292
 
 
293
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
294
 
 
295
    TODO: Check it's reasonably well-formed.
 
296
    """
 
297
    v = _get_user_id()
 
298
    if v:
 
299
        return v
 
300
    
 
301
    name, email = _auto_user_id()
 
302
    if name:
 
303
        return '%s <%s>' % (name, email)
 
304
    else:
 
305
        return email
 
306
 
 
307
 
 
308
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
 
309
def user_email():
 
310
    """Return just the email component of a username."""
 
311
    e = _get_user_id()
 
312
    if e:
 
313
        m = _EMAIL_RE.search(e)
 
314
        if not m:
 
315
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
 
316
        return m.group(0)
 
317
 
 
318
    return _auto_user_id()[1]
 
319
    
 
320
 
 
321
 
 
322
def compare_files(a, b):
 
323
    """Returns true if equal in contents"""
 
324
    BUFSIZE = 4096
 
325
    while True:
 
326
        ai = a.read(BUFSIZE)
 
327
        bi = b.read(BUFSIZE)
 
328
        if ai != bi:
 
329
            return False
 
330
        if ai == '':
 
331
            return True
 
332
 
 
333
 
 
334
 
 
335
def local_time_offset(t=None):
 
336
    """Return offset of local zone from GMT, either at present or at time t."""
 
337
    # python2.3 localtime() can't take None
 
338
    if t == None:
 
339
        t = time.time()
 
340
        
 
341
    if time.localtime(t).tm_isdst and time.daylight:
 
342
        return -time.altzone
 
343
    else:
 
344
        return -time.timezone
 
345
 
 
346
    
 
347
def format_date(t, offset=0, timezone='original'):
 
348
    ## TODO: Perhaps a global option to use either universal or local time?
 
349
    ## Or perhaps just let people set $TZ?
 
350
    assert isinstance(t, float)
 
351
    
 
352
    if timezone == 'utc':
 
353
        tt = time.gmtime(t)
 
354
        offset = 0
 
355
    elif timezone == 'original':
 
356
        if offset == None:
 
357
            offset = 0
 
358
        tt = time.gmtime(t + offset)
 
359
    elif timezone == 'local':
 
360
        tt = time.localtime(t)
 
361
        offset = local_time_offset(t)
 
362
    else:
 
363
        raise BzrError("unsupported timezone format %r",
 
364
                ['options are "utc", "original", "local"'])
 
365
 
 
366
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
367
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
368
 
 
369
 
 
370
def compact_date(when):
 
371
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
 
372
    
 
373
 
 
374
 
 
375
def filesize(f):
 
376
    """Return size of given open file."""
 
377
    return os.fstat(f.fileno())[ST_SIZE]
 
378
 
 
379
 
 
380
if hasattr(os, 'urandom'): # python 2.4 and later
 
381
    rand_bytes = os.urandom
 
382
elif sys.platform == 'linux2':
 
383
    rand_bytes = file('/dev/urandom', 'rb').read
 
384
else:
 
385
    # not well seeded, but better than nothing
 
386
    def rand_bytes(n):
 
387
        import random
 
388
        s = ''
 
389
        while n:
 
390
            s += chr(random.randint(0, 255))
 
391
            n -= 1
 
392
        return s
 
393
 
 
394
 
 
395
## TODO: We could later have path objects that remember their list
 
396
## decomposition (might be too tricksy though.)
 
397
 
 
398
def splitpath(p):
 
399
    """Turn string into list of parts.
 
400
 
 
401
    >>> splitpath('a')
 
402
    ['a']
 
403
    >>> splitpath('a/b')
 
404
    ['a', 'b']
 
405
    >>> splitpath('a/./b')
 
406
    ['a', 'b']
 
407
    >>> splitpath('a/.b')
 
408
    ['a', '.b']
 
409
    >>> splitpath('a/../b')
 
410
    Traceback (most recent call last):
 
411
    ...
 
412
    BzrError: sorry, '..' not allowed in path
 
413
    """
 
414
    assert isinstance(p, types.StringTypes)
 
415
 
 
416
    # split on either delimiter because people might use either on
 
417
    # Windows
 
418
    ps = re.split(r'[\\/]', p)
 
419
 
 
420
    rps = []
 
421
    for f in ps:
 
422
        if f == '..':
 
423
            raise BzrError("sorry, %r not allowed in path" % f)
 
424
        elif (f == '.') or (f == ''):
 
425
            pass
 
426
        else:
 
427
            rps.append(f)
 
428
    return rps
 
429
 
 
430
def joinpath(p):
 
431
    assert isinstance(p, list)
 
432
    for f in p:
 
433
        if (f == '..') or (f == None) or (f == ''):
 
434
            raise BzrError("sorry, %r not allowed in path" % f)
 
435
    return os.path.join(*p)
 
436
 
 
437
 
 
438
def appendpath(p1, p2):
 
439
    if p1 == '':
 
440
        return p2
 
441
    else:
 
442
        return os.path.join(p1, p2)
 
443
    
 
444
 
 
445
def extern_command(cmd, ignore_errors = False):
 
446
    mutter('external command: %s' % `cmd`)
 
447
    if os.system(cmd):
 
448
        if not ignore_errors:
 
449
            raise BzrError('command failed')
 
450
 
 
451
 
 
452
def _read_config_value(name):
 
453
    """Read a config value from the file ~/.bzr.conf/<name>
 
454
    Return None if the file does not exist"""
 
455
    try:
 
456
        f = file(os.path.join(config_dir(), name), "r")
 
457
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
458
    except IOError, e:
 
459
        if e.errno == errno.ENOENT:
 
460
            return None
 
461
        raise
 
462
 
 
463
 
 
464
def _get_editor():
 
465
    """Return a sequence of possible editor binaries for the current platform"""
 
466
    e = _read_config_value("editor")
 
467
    if e is not None:
 
468
        yield e
 
469
        
 
470
    if os.name == "windows":
 
471
        yield "notepad.exe"
 
472
    elif os.name == "posix":
 
473
        try:
 
474
            yield os.environ["EDITOR"]
 
475
        except KeyError:
 
476
            yield "/usr/bin/vi"
 
477
 
 
478
 
 
479
def _run_editor(filename):
 
480
    """Try to execute an editor to edit the commit message. Returns True on success,
 
481
    False on failure"""
 
482
    for e in _get_editor():
 
483
        x = os.spawnvp(os.P_WAIT, e, (e, filename))
 
484
        if x == 0:
 
485
            return True
 
486
        elif x == 127:
 
487
            continue
 
488
        else:
 
489
            break
 
490
    raise BzrError("Could not start any editor. Please specify $EDITOR or use ~/.bzr.conf/editor")
 
491
    return False
 
492
                          
 
493
 
 
494
def get_text_message(infotext, ignoreline = "default"):
 
495
    import tempfile
 
496
    
 
497
    if ignoreline == "default":
 
498
        ignoreline = "-- This line and the following will be ignored --"
 
499
        
 
500
    try:
 
501
        tmp_fileno, msgfilename = tempfile.mkstemp()
 
502
        msgfile = os.close(tmp_fileno)
 
503
        if infotext is not None and infotext != "":
 
504
            hasinfo = True
 
505
            msgfile = file(msgfilename, "w")
 
506
            msgfile.write("\n\n%s\n\n%s" % (ignoreline, infotext))
 
507
            msgfile.close()
 
508
        else:
 
509
            hasinfo = False
 
510
 
 
511
        if not _run_editor(msgfilename):
 
512
            return None
 
513
        
 
514
        started = False
 
515
        msg = []
 
516
        lastline, nlines = 0, 0
 
517
        for line in file(msgfilename, "r"):
 
518
            stripped_line = line.strip()
 
519
            # strip empty line before the log message starts
 
520
            if not started:
 
521
                if stripped_line != "":
 
522
                    started = True
 
523
                else:
 
524
                    continue
 
525
            # check for the ignore line only if there
 
526
            # is additional information at the end
 
527
            if hasinfo and stripped_line == ignoreline:
 
528
                break
 
529
            nlines += 1
 
530
            # keep track of the last line that had some content
 
531
            if stripped_line != "":
 
532
                lastline = nlines
 
533
            msg.append(line)
 
534
            
 
535
        if len(msg) == 0:
 
536
            return None
 
537
        # delete empty lines at the end
 
538
        del msg[lastline:]
 
539
        # add a newline at the end, if needed
 
540
        if not msg[-1].endswith("\n"):
 
541
            return "%s%s" % ("".join(msg), "\n")
 
542
        else:
 
543
            return "".join(msg)
 
544
    finally:
 
545
        # delete the msg file in any case
 
546
        try: os.unlink(msgfilename)
 
547
        except IOError: pass