/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-10-01 06:48:01 UTC
  • mto: (1185.12.13)
  • mto: This revision was merged to the branch mainline in revision 1419.
  • Revision ID: aaron.bentley@utoronto.ca-20051001064801-7400c2ed0fe26080
Made iter_conflicts a WorkingTree method

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
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 sys
 
28
import time
 
29
import types
 
30
 
 
31
import bzrlib
 
32
from bzrlib.errors import BzrError
 
33
from bzrlib.trace import mutter
 
34
 
 
35
 
 
36
def make_readonly(filename):
 
37
    """Make a filename read-only."""
 
38
    mod = os.stat(filename).st_mode
 
39
    mod = mod & 0777555
 
40
    os.chmod(filename, mod)
 
41
 
 
42
 
 
43
def make_writable(filename):
 
44
    mod = os.stat(filename).st_mode
 
45
    mod = mod | 0200
 
46
    os.chmod(filename, mod)
 
47
 
 
48
 
 
49
_QUOTE_RE = None
 
50
 
 
51
 
 
52
def quotefn(f):
 
53
    """Return a quoted filename filename
 
54
 
 
55
    This previously used backslash quoting, but that works poorly on
 
56
    Windows."""
 
57
    # TODO: I'm not really sure this is the best format either.x
 
58
    global _QUOTE_RE
 
59
    if _QUOTE_RE == None:
 
60
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
61
        
 
62
    if _QUOTE_RE.search(f):
 
63
        return '"' + f + '"'
 
64
    else:
 
65
        return f
 
66
 
 
67
 
 
68
def file_kind(f):
 
69
    mode = os.lstat(f)[ST_MODE]
 
70
    if S_ISREG(mode):
 
71
        return 'file'
 
72
    elif S_ISDIR(mode):
 
73
        return 'directory'
 
74
    elif S_ISLNK(mode):
 
75
        return 'symlink'
 
76
    elif S_ISCHR(mode):
 
77
        return 'chardev'
 
78
    elif S_ISBLK(mode):
 
79
        return 'block'
 
80
    elif S_ISFIFO(mode):
 
81
        return 'fifo'
 
82
    elif S_ISSOCK(mode):
 
83
        return 'socket'
 
84
    else:
 
85
        return 'unknown'
 
86
 
 
87
 
 
88
def kind_marker(kind):
 
89
    if kind == 'file':
 
90
        return ''
 
91
    elif kind == 'directory':
 
92
        return '/'
 
93
    elif kind == 'symlink':
 
94
        return '@'
 
95
    else:
 
96
        raise BzrError('invalid file kind %r' % kind)
 
97
 
 
98
 
 
99
def backup_file(fn):
 
100
    """Copy a file to a backup.
 
101
 
 
102
    Backups are named in GNU-style, with a ~ suffix.
 
103
 
 
104
    If the file is already a backup, it's not copied.
 
105
    """
 
106
    if fn[-1] == '~':
 
107
        return
 
108
    bfn = fn + '~'
 
109
 
 
110
    inf = file(fn, 'rb')
 
111
    try:
 
112
        content = inf.read()
 
113
    finally:
 
114
        inf.close()
 
115
    
 
116
    outf = file(bfn, 'wb')
 
117
    try:
 
118
        outf.write(content)
 
119
    finally:
 
120
        outf.close()
 
121
 
 
122
if os.name == 'nt':
 
123
    import shutil
 
124
    rename = shutil.move
 
125
else:
 
126
    rename = os.rename
 
127
 
 
128
 
 
129
def isdir(f):
 
130
    """True if f is an accessible directory."""
 
131
    try:
 
132
        return S_ISDIR(os.lstat(f)[ST_MODE])
 
133
    except OSError:
 
134
        return False
 
135
 
 
136
 
 
137
def isfile(f):
 
138
    """True if f is a regular file."""
 
139
    try:
 
140
        return S_ISREG(os.lstat(f)[ST_MODE])
 
141
    except OSError:
 
142
        return False
 
143
 
 
144
 
 
145
def is_inside(dir, fname):
 
146
    """True if fname is inside dir.
 
147
    
 
148
    The parameters should typically be passed to os.path.normpath first, so
 
149
    that . and .. and repeated slashes are eliminated, and the separators
 
150
    are canonical for the platform.
 
151
    
 
152
    The empty string as a dir name is taken as top-of-tree and matches 
 
153
    everything.
 
154
    
 
155
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
156
    True
 
157
    >>> is_inside('src', 'srccontrol')
 
158
    False
 
159
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
160
    True
 
161
    >>> is_inside('foo.c', 'foo.c')
 
162
    True
 
163
    >>> is_inside('foo.c', '')
 
164
    False
 
165
    >>> is_inside('', 'foo.c')
 
166
    True
 
167
    """
 
168
    # XXX: Most callers of this can actually do something smarter by 
 
169
    # looking at the inventory
 
170
    if dir == fname:
 
171
        return True
 
172
    
 
173
    if dir == '':
 
174
        return True
 
175
 
 
176
    if dir[-1] != os.sep:
 
177
        dir += os.sep
 
178
 
 
179
    return fname.startswith(dir)
 
180
 
 
181
 
 
182
def is_inside_any(dir_list, fname):
 
183
    """True if fname is inside any of given dirs."""
 
184
    for dirname in dir_list:
 
185
        if is_inside(dirname, fname):
 
186
            return True
 
187
    else:
 
188
        return False
 
189
 
 
190
 
 
191
def pumpfile(fromfile, tofile):
 
192
    """Copy contents of one file to another."""
 
193
    tofile.write(fromfile.read())
 
194
 
 
195
 
 
196
def sha_file(f):
 
197
    if hasattr(f, 'tell'):
 
198
        assert f.tell() == 0
 
199
    s = sha.new()
 
200
    BUFSIZE = 128<<10
 
201
    while True:
 
202
        b = f.read(BUFSIZE)
 
203
        if not b:
 
204
            break
 
205
        s.update(b)
 
206
    return s.hexdigest()
 
207
 
 
208
 
 
209
 
 
210
def sha_strings(strings):
 
211
    """Return the sha-1 of concatenation of strings"""
 
212
    s = sha.new()
 
213
    map(s.update, strings)
 
214
    return s.hexdigest()
 
215
 
 
216
 
 
217
def sha_string(f):
 
218
    s = sha.new()
 
219
    s.update(f)
 
220
    return s.hexdigest()
 
221
 
 
222
 
 
223
def fingerprint_file(f):
 
224
    s = sha.new()
 
225
    b = f.read()
 
226
    s.update(b)
 
227
    size = len(b)
 
228
    return {'size': size,
 
229
            'sha1': s.hexdigest()}
 
230
 
 
231
 
 
232
def config_dir():
 
233
    """Return per-user configuration directory.
 
234
 
 
235
    By default this is ~/.bzr.conf/
 
236
    
 
237
    TODO: Global option --config-dir to override this.
 
238
    """
 
239
    return os.path.join(os.path.expanduser("~"), ".bzr.conf")
 
240
 
 
241
 
 
242
def _auto_user_id():
 
243
    """Calculate automatic user identification.
 
244
 
 
245
    Returns (realname, email).
 
246
 
 
247
    Only used when none is set in the environment or the id file.
 
248
 
 
249
    This previously used the FQDN as the default domain, but that can
 
250
    be very slow on machines where DNS is broken.  So now we simply
 
251
    use the hostname.
 
252
    """
 
253
    import socket
 
254
 
 
255
    # XXX: Any good way to get real user name on win32?
 
256
 
 
257
    try:
 
258
        import pwd
 
259
        uid = os.getuid()
 
260
        w = pwd.getpwuid(uid)
 
261
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
262
        username = w.pw_name.decode(bzrlib.user_encoding)
 
263
        comma = gecos.find(',')
 
264
        if comma == -1:
 
265
            realname = gecos
 
266
        else:
 
267
            realname = gecos[:comma]
 
268
        if not realname:
 
269
            realname = username
 
270
 
 
271
    except ImportError:
 
272
        import getpass
 
273
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
274
 
 
275
    return realname, (username + '@' + socket.gethostname())
 
276
 
 
277
 
 
278
def _get_user_id(branch):
 
279
    """Return the full user id from a file or environment variable.
 
280
 
 
281
    e.g. "John Hacker <jhacker@foo.org>"
 
282
 
 
283
    branch
 
284
        A branch to use for a per-branch configuration, or None.
 
285
 
 
286
    The following are searched in order:
 
287
 
 
288
    1. $BZREMAIL
 
289
    2. .bzr/email for this branch.
 
290
    3. ~/.bzr.conf/email
 
291
    4. $EMAIL
 
292
    """
 
293
    v = os.environ.get('BZREMAIL')
 
294
    if v:
 
295
        return v.decode(bzrlib.user_encoding)
 
296
 
 
297
    if branch:
 
298
        try:
 
299
            return (branch.controlfile("email", "r") 
 
300
                    .read()
 
301
                    .decode(bzrlib.user_encoding)
 
302
                    .rstrip("\r\n"))
 
303
        except IOError, e:
 
304
            if e.errno != errno.ENOENT:
 
305
                raise
 
306
        except BzrError, e:
 
307
            pass
 
308
    
 
309
    try:
 
310
        return (open(os.path.join(config_dir(), "email"))
 
311
                .read()
 
312
                .decode(bzrlib.user_encoding)
 
313
                .rstrip("\r\n"))
 
314
    except IOError, e:
 
315
        if e.errno != errno.ENOENT:
 
316
            raise e
 
317
 
 
318
    v = os.environ.get('EMAIL')
 
319
    if v:
 
320
        return v.decode(bzrlib.user_encoding)
 
321
    else:    
 
322
        return None
 
323
 
 
324
 
 
325
def username(branch):
 
326
    """Return email-style username.
 
327
 
 
328
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
329
 
 
330
    TODO: Check it's reasonably well-formed.
 
331
    """
 
332
    v = _get_user_id(branch)
 
333
    if v:
 
334
        return v
 
335
    
 
336
    name, email = _auto_user_id()
 
337
    if name:
 
338
        return '%s <%s>' % (name, email)
 
339
    else:
 
340
        return email
 
341
 
 
342
 
 
343
def user_email(branch):
 
344
    """Return just the email component of a username."""
 
345
    e = _get_user_id(branch)
 
346
    if e:
 
347
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
348
        if not m:
 
349
            raise BzrError("%r doesn't seem to contain "
 
350
                           "a reasonable email address" % e)
 
351
        return m.group(0)
 
352
 
 
353
    return _auto_user_id()[1]
 
354
 
 
355
 
 
356
def compare_files(a, b):
 
357
    """Returns true if equal in contents"""
 
358
    BUFSIZE = 4096
 
359
    while True:
 
360
        ai = a.read(BUFSIZE)
 
361
        bi = b.read(BUFSIZE)
 
362
        if ai != bi:
 
363
            return False
 
364
        if ai == '':
 
365
            return True
 
366
 
 
367
 
 
368
def local_time_offset(t=None):
 
369
    """Return offset of local zone from GMT, either at present or at time t."""
 
370
    # python2.3 localtime() can't take None
 
371
    if t == None:
 
372
        t = time.time()
 
373
        
 
374
    if time.localtime(t).tm_isdst and time.daylight:
 
375
        return -time.altzone
 
376
    else:
 
377
        return -time.timezone
 
378
 
 
379
    
 
380
def format_date(t, offset=0, timezone='original'):
 
381
    ## TODO: Perhaps a global option to use either universal or local time?
 
382
    ## Or perhaps just let people set $TZ?
 
383
    assert isinstance(t, float)
 
384
    
 
385
    if timezone == 'utc':
 
386
        tt = time.gmtime(t)
 
387
        offset = 0
 
388
    elif timezone == 'original':
 
389
        if offset == None:
 
390
            offset = 0
 
391
        tt = time.gmtime(t + offset)
 
392
    elif timezone == 'local':
 
393
        tt = time.localtime(t)
 
394
        offset = local_time_offset(t)
 
395
    else:
 
396
        raise BzrError("unsupported timezone format %r" % timezone,
 
397
                       ['options are "utc", "original", "local"'])
 
398
 
 
399
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
400
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
401
 
 
402
 
 
403
def compact_date(when):
 
404
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
 
405
    
 
406
 
 
407
 
 
408
def filesize(f):
 
409
    """Return size of given open file."""
 
410
    return os.fstat(f.fileno())[ST_SIZE]
 
411
 
 
412
# Define rand_bytes based on platform.
 
413
try:
 
414
    # Python 2.4 and later have os.urandom,
 
415
    # but it doesn't work on some arches
 
416
    os.urandom(1)
 
417
    rand_bytes = os.urandom
 
418
except (NotImplementedError, AttributeError):
 
419
    # If python doesn't have os.urandom, or it doesn't work,
 
420
    # then try to first pull random data from /dev/urandom
 
421
    if os.path.exists("/dev/urandom"):
 
422
        rand_bytes = file('/dev/urandom', 'rb').read
 
423
    # Otherwise, use this hack as a last resort
 
424
    else:
 
425
        # not well seeded, but better than nothing
 
426
        def rand_bytes(n):
 
427
            import random
 
428
            s = ''
 
429
            while n:
 
430
                s += chr(random.randint(0, 255))
 
431
                n -= 1
 
432
            return s
 
433
 
 
434
## TODO: We could later have path objects that remember their list
 
435
## decomposition (might be too tricksy though.)
 
436
 
 
437
def splitpath(p):
 
438
    """Turn string into list of parts.
 
439
 
 
440
    >>> splitpath('a')
 
441
    ['a']
 
442
    >>> splitpath('a/b')
 
443
    ['a', 'b']
 
444
    >>> splitpath('a/./b')
 
445
    ['a', 'b']
 
446
    >>> splitpath('a/.b')
 
447
    ['a', '.b']
 
448
    >>> splitpath('a/../b')
 
449
    Traceback (most recent call last):
 
450
    ...
 
451
    BzrError: sorry, '..' not allowed in path
 
452
    """
 
453
    assert isinstance(p, types.StringTypes)
 
454
 
 
455
    # split on either delimiter because people might use either on
 
456
    # Windows
 
457
    ps = re.split(r'[\\/]', p)
 
458
 
 
459
    rps = []
 
460
    for f in ps:
 
461
        if f == '..':
 
462
            raise BzrError("sorry, %r not allowed in path" % f)
 
463
        elif (f == '.') or (f == ''):
 
464
            pass
 
465
        else:
 
466
            rps.append(f)
 
467
    return rps
 
468
 
 
469
def joinpath(p):
 
470
    assert isinstance(p, list)
 
471
    for f in p:
 
472
        if (f == '..') or (f == None) or (f == ''):
 
473
            raise BzrError("sorry, %r not allowed in path" % f)
 
474
    return os.path.join(*p)
 
475
 
 
476
 
 
477
def appendpath(p1, p2):
 
478
    if p1 == '':
 
479
        return p2
 
480
    else:
 
481
        return os.path.join(p1, p2)
 
482
    
 
483
 
 
484
def _read_config_value(name):
 
485
    """Read a config value from the file ~/.bzr.conf/<name>
 
486
    Return None if the file does not exist"""
 
487
    try:
 
488
        f = file(os.path.join(config_dir(), name), "r")
 
489
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
490
    except IOError, e:
 
491
        if e.errno == errno.ENOENT:
 
492
            return None
 
493
        raise
 
494
 
 
495
 
 
496
def split_lines(s):
 
497
    """Split s into lines, but without removing the newline characters."""
 
498
    return StringIO(s).readlines()
 
499
 
 
500
 
 
501
def hardlinks_good():
 
502
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
503
 
 
504
 
 
505
def link_or_copy(src, dest):
 
506
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
507
    if not hardlinks_good():
 
508
        copyfile(src, dest)
 
509
        return
 
510
    try:
 
511
        os.link(src, dest)
 
512
    except (OSError, IOError), e:
 
513
        if e.errno != errno.EXDEV:
 
514
            raise
 
515
        copyfile(src, dest)