/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: Aaron Bentley
  • Date: 2005-07-27 16:44:44 UTC
  • mto: (1092.1.41) (1185.3.4) (974.1.47)
  • mto: This revision was merged to the branch mainline in revision 1020.
  • Revision ID: abentley@panoramicfeedback.com-20050727164443-b5aa44851803207b
Added unit tests

Show diffs side-by-side

added added

removed removed

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