← 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-09-29 12:49:59 UTC
  • mto: (1185.14.2)
  • mto: This revision was merged to the branch mainline in revision 1396.
  • Revision ID: mbp@sourcefrog.net-20050929124959-df3f175844fc90ed
- remove redundant import

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
1
# Bazaar-NG -- distributed version control
2
 
 
 
2
#
3
3
# Copyright (C) 2005 by Canonical Ltd
4
 
 
 
4
#
5
5
# This program is free software; you can redistribute it and/or modify
6
6
# it under the terms of the GNU General Public License as published by
7
7
# the Free Software Foundation; either version 2 of the License, or
8
8
# (at your option) any later version.
9
 
 
 
9
#
10
10
# This program is distributed in the hope that it will be useful,
11
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
13
# GNU General Public License for more details.
14
 
 
 
14
#
15
15
# You should have received a copy of the GNU General Public License
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, errno, sys
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
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
21
30
 
22
 
from errors import bailout, BzrError
23
 
from trace import mutter
24
31
import bzrlib
 
32
from bzrlib.errors import BzrError
 
33
from bzrlib.trace import mutter
 
34
 
25
35
 
26
36
def make_readonly(filename):
27
37
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
38
    mod = os.stat(filename).st_mode
30
39
    mod = mod & 0777555
31
40
    os.chmod(filename, mod)
37
46
    os.chmod(filename, mod)
38
47
 
39
48
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
49
_QUOTE_RE = None
 
50
 
 
51
 
41
52
def quotefn(f):
42
 
    """Return shell-quoted filename"""
43
 
    ## We could be a bit more terse by using double-quotes etc
44
 
    f = _QUOTE_RE.sub(r'\\\1', f)
45
 
    if f[0] == '~':
46
 
        f[0:1] = r'\~' 
47
 
    return 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
48
66
 
49
67
 
50
68
def file_kind(f):
55
73
        return 'directory'
56
74
    elif S_ISLNK(mode):
57
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'
58
84
    else:
59
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
 
85
        return 'unknown'
60
86
 
61
87
 
62
88
def kind_marker(kind):
70
96
        raise BzrError('invalid file kind %r' % kind)
71
97
 
72
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
 
73
128
 
74
129
def isdir(f):
75
130
    """True if f is an accessible directory."""
79
134
        return False
80
135
 
81
136
 
82
 
 
83
137
def isfile(f):
84
138
    """True if f is a regular file."""
85
139
    try:
90
144
 
91
145
def is_inside(dir, fname):
92
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
93
167
    """
94
 
    return os.path.commonprefix([dir, fname]) == dir
 
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)
95
180
 
96
181
 
97
182
def is_inside_any(dir_list, fname):
98
183
    """True if fname is inside any of given dirs."""
99
 
    # quick scan for perfect match
100
 
    if fname in dir_list:
101
 
        return True
102
 
    
103
184
    for dirname in dir_list:
104
185
        if is_inside(dirname, fname):
105
186
            return True
112
193
    tofile.write(fromfile.read())
113
194
 
114
195
 
115
 
def uuid():
116
 
    """Return a new UUID"""
117
 
    try:
118
 
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
119
 
    except IOError:
120
 
        return chomp(os.popen('uuidgen').readline())
121
 
 
122
 
 
123
196
def sha_file(f):
124
 
    import sha
125
197
    if hasattr(f, 'tell'):
126
198
        assert f.tell() == 0
127
199
    s = sha.new()
134
206
    return s.hexdigest()
135
207
 
136
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
 
137
217
def sha_string(f):
138
 
    import sha
139
218
    s = sha.new()
140
219
    s.update(f)
141
220
    return s.hexdigest()
142
221
 
143
222
 
144
 
 
145
223
def fingerprint_file(f):
146
 
    import sha
147
224
    s = sha.new()
148
225
    b = f.read()
149
226
    s.update(b)
159
236
    
160
237
    TODO: Global option --config-dir to override this.
161
238
    """
162
 
    return os.path.expanduser("~/.bzr.conf")
 
239
    return os.path.join(os.path.expanduser("~"), ".bzr.conf")
163
240
 
164
241
 
165
242
def _auto_user_id():
198
275
    return realname, (username + '@' + socket.gethostname())
199
276
 
200
277
 
201
 
def _get_user_id():
 
278
def _get_user_id(branch):
202
279
    """Return the full user id from a file or environment variable.
203
280
 
204
 
    TODO: Allow taking this from a file in the branch directory too
205
 
    for per-branch ids."""
 
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
    """
206
293
    v = os.environ.get('BZREMAIL')
207
294
    if v:
208
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
209
308
    
210
309
    try:
211
310
        return (open(os.path.join(config_dir(), "email"))
223
322
        return None
224
323
 
225
324
 
226
 
def username():
 
325
def username(branch):
227
326
    """Return email-style username.
228
327
 
229
328
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
230
329
 
231
330
    TODO: Check it's reasonably well-formed.
232
331
    """
233
 
    v = _get_user_id()
 
332
    v = _get_user_id(branch)
234
333
    if v:
235
334
        return v
236
335
    
241
340
        return email
242
341
 
243
342
 
244
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
245
 
def user_email():
 
343
def user_email(branch):
246
344
    """Return just the email component of a username."""
247
 
    e = _get_user_id()
 
345
    e = _get_user_id(branch)
248
346
    if e:
249
 
        m = _EMAIL_RE.search(e)
 
347
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
250
348
        if not m:
251
 
            bailout("%r doesn't seem to contain a reasonable email address" % e)
 
349
            raise BzrError("%r doesn't seem to contain "
 
350
                           "a reasonable email address" % e)
252
351
        return m.group(0)
253
352
 
254
353
    return _auto_user_id()[1]
255
 
    
256
354
 
257
355
 
258
356
def compare_files(a, b):
267
365
            return True
268
366
 
269
367
 
270
 
 
271
368
def local_time_offset(t=None):
272
369
    """Return offset of local zone from GMT, either at present or at time t."""
273
370
    # python2.3 localtime() can't take None
296
393
        tt = time.localtime(t)
297
394
        offset = local_time_offset(t)
298
395
    else:
299
 
        bailout("unsupported timezone format %r",
300
 
                ['options are "utc", "original", "local"'])
 
396
        raise BzrError("unsupported timezone format %r" % timezone,
 
397
                       ['options are "utc", "original", "local"'])
301
398
 
302
399
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
303
400
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
312
409
    """Return size of given open file."""
313
410
    return os.fstat(f.fileno())[ST_SIZE]
314
411
 
315
 
 
316
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
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)
317
417
    rand_bytes = os.urandom
318
 
elif sys.platform == 'linux2':
319
 
    rand_bytes = file('/dev/urandom', 'rb').read
320
 
else:
321
 
    # not well seeded, but better than nothing
322
 
    def rand_bytes(n):
323
 
        import random
324
 
        s = ''
325
 
        while n:
326
 
            s += chr(random.randint(0, 255))
327
 
            n -= 1
328
 
        return s
329
 
 
 
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
330
433
 
331
434
## TODO: We could later have path objects that remember their list
332
435
## decomposition (might be too tricksy though.)
345
448
    >>> splitpath('a/../b')
346
449
    Traceback (most recent call last):
347
450
    ...
348
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
451
    BzrError: sorry, '..' not allowed in path
349
452
    """
350
453
    assert isinstance(p, types.StringTypes)
351
454
 
356
459
    rps = []
357
460
    for f in ps:
358
461
        if f == '..':
359
 
            bailout("sorry, %r not allowed in path" % f)
 
462
            raise BzrError("sorry, %r not allowed in path" % f)
360
463
        elif (f == '.') or (f == ''):
361
464
            pass
362
465
        else:
367
470
    assert isinstance(p, list)
368
471
    for f in p:
369
472
        if (f == '..') or (f == None) or (f == ''):
370
 
            bailout("sorry, %r not allowed in path" % f)
 
473
            raise BzrError("sorry, %r not allowed in path" % f)
371
474
    return os.path.join(*p)
372
475
 
373
476
 
378
481
        return os.path.join(p1, p2)
379
482
    
380
483
 
381
 
def extern_command(cmd, ignore_errors = False):
382
 
    mutter('external command: %s' % `cmd`)
383
 
    if os.system(cmd):
384
 
        if not ignore_errors:
385
 
            bailout('command failed')
386
 
 
 
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)