/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

Fix formatting, remove catch-all for exceptions when opening local repositories.

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
 
    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