← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2005-09-26 08:56:15 UTC
  • mto: (1092.3.4)
  • mto: This revision was merged to the branch mainline in revision 1390.
  • Revision ID: robertc@robertcollins.net-20050926085615-99b8fb35f41b541d
massive patch from Alexander Belchenko - many PEP8 fixes, removes unused function uuid

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
20
 
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
19
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
 
20
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
21
import errno
 
22
import os
 
23
import re
 
24
import sha
 
25
import sys
 
26
import time
 
27
import types
21
28
 
22
 
from errors import bailout, BzrError
23
 
from trace import mutter
24
29
import bzrlib
 
30
from bzrlib.errors import BzrError
 
31
from bzrlib.trace import mutter
 
32
 
25
33
 
26
34
def make_readonly(filename):
27
35
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
36
    mod = os.stat(filename).st_mode
30
37
    mod = mod & 0777555
31
38
    os.chmod(filename, mod)
37
44
    os.chmod(filename, mod)
38
45
 
39
46
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
47
_QUOTE_RE = None
 
48
 
 
49
 
41
50
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
 
51
    """Return a quoted filename filename
 
52
 
 
53
    This previously used backslash quoting, but that works poorly on
 
54
    Windows."""
 
55
    # TODO: I'm not really sure this is the best format either.x
 
56
    global _QUOTE_RE
 
57
    if _QUOTE_RE == None:
 
58
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
59
        
 
60
    if _QUOTE_RE.search(f):
 
61
        return '"' + f + '"'
 
62
    else:
 
63
        return f
48
64
 
49
65
 
50
66
def file_kind(f):
55
71
        return 'directory'
56
72
    elif S_ISLNK(mode):
57
73
        return 'symlink'
58
 
    else:
59
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f)) 
60
 
 
 
74
    elif S_ISCHR(mode):
 
75
        return 'chardev'
 
76
    elif S_ISBLK(mode):
 
77
        return 'block'
 
78
    elif S_ISFIFO(mode):
 
79
        return 'fifo'
 
80
    elif S_ISSOCK(mode):
 
81
        return 'socket'
 
82
    else:
 
83
        return 'unknown'
 
84
 
 
85
 
 
86
def kind_marker(kind):
 
87
    if kind == 'file':
 
88
        return ''
 
89
    elif kind == 'directory':
 
90
        return '/'
 
91
    elif kind == 'symlink':
 
92
        return '@'
 
93
    else:
 
94
        raise BzrError('invalid file kind %r' % kind)
 
95
 
 
96
 
 
97
def backup_file(fn):
 
98
    """Copy a file to a backup.
 
99
 
 
100
    Backups are named in GNU-style, with a ~ suffix.
 
101
 
 
102
    If the file is already a backup, it's not copied.
 
103
    """
 
104
    if fn[-1] == '~':
 
105
        return
 
106
    bfn = fn + '~'
 
107
 
 
108
    inf = file(fn, 'rb')
 
109
    try:
 
110
        content = inf.read()
 
111
    finally:
 
112
        inf.close()
 
113
    
 
114
    outf = file(bfn, 'wb')
 
115
    try:
 
116
        outf.write(content)
 
117
    finally:
 
118
        outf.close()
 
119
 
 
120
if os.name == 'nt':
 
121
    import shutil
 
122
    rename = shutil.move
 
123
else:
 
124
    rename = os.rename
61
125
 
62
126
 
63
127
def isdir(f):
68
132
        return False
69
133
 
70
134
 
71
 
 
72
135
def isfile(f):
73
136
    """True if f is a regular file."""
74
137
    try:
77
140
        return False
78
141
 
79
142
 
 
143
def is_inside(dir, fname):
 
144
    """True if fname is inside dir.
 
145
    
 
146
    The parameters should typically be passed to os.path.normpath first, so
 
147
    that . and .. and repeated slashes are eliminated, and the separators
 
148
    are canonical for the platform.
 
149
    
 
150
    The empty string as a dir name is taken as top-of-tree and matches 
 
151
    everything.
 
152
    
 
153
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
154
    True
 
155
    >>> is_inside('src', 'srccontrol')
 
156
    False
 
157
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
158
    True
 
159
    >>> is_inside('foo.c', 'foo.c')
 
160
    True
 
161
    >>> is_inside('foo.c', '')
 
162
    False
 
163
    >>> is_inside('', 'foo.c')
 
164
    True
 
165
    """
 
166
    # XXX: Most callers of this can actually do something smarter by 
 
167
    # looking at the inventory
 
168
    if dir == fname:
 
169
        return True
 
170
    
 
171
    if dir == '':
 
172
        return True
 
173
 
 
174
    if dir[-1] != os.sep:
 
175
        dir += os.sep
 
176
 
 
177
    return fname.startswith(dir)
 
178
 
 
179
 
 
180
def is_inside_any(dir_list, fname):
 
181
    """True if fname is inside any of given dirs."""
 
182
    for dirname in dir_list:
 
183
        if is_inside(dirname, fname):
 
184
            return True
 
185
    else:
 
186
        return False
 
187
 
 
188
 
80
189
def pumpfile(fromfile, tofile):
81
190
    """Copy contents of one file to another."""
82
191
    tofile.write(fromfile.read())
83
192
 
84
193
 
85
 
def uuid():
86
 
    """Return a new UUID"""
87
 
    try:
88
 
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
89
 
    except IOError:
90
 
        return chomp(os.popen('uuidgen').readline())
91
 
 
92
 
 
93
194
def sha_file(f):
94
 
    import sha
95
195
    if hasattr(f, 'tell'):
96
196
        assert f.tell() == 0
97
197
    s = sha.new()
105
205
 
106
206
 
107
207
def sha_string(f):
108
 
    import sha
109
208
    s = sha.new()
110
209
    s.update(f)
111
210
    return s.hexdigest()
112
211
 
113
212
 
114
 
 
115
213
def fingerprint_file(f):
116
 
    import sha
117
214
    s = sha.new()
118
215
    b = f.read()
119
216
    s.update(b)
129
226
    
130
227
    TODO: Global option --config-dir to override this.
131
228
    """
132
 
    return os.path.expanduser("~/.bzr.conf")
 
229
    return os.path.join(os.path.expanduser("~"), ".bzr.conf")
133
230
 
134
231
 
135
232
def _auto_user_id():
168
265
    return realname, (username + '@' + socket.gethostname())
169
266
 
170
267
 
171
 
def _get_user_id():
 
268
def _get_user_id(branch):
172
269
    """Return the full user id from a file or environment variable.
173
270
 
174
 
    TODO: Allow taking this from a file in the branch directory too
175
 
    for per-branch ids."""
 
271
    e.g. "John Hacker <jhacker@foo.org>"
 
272
 
 
273
    branch
 
274
        A branch to use for a per-branch configuration, or None.
 
275
 
 
276
    The following are searched in order:
 
277
 
 
278
    1. $BZREMAIL
 
279
    2. .bzr/email for this branch.
 
280
    3. ~/.bzr.conf/email
 
281
    4. $EMAIL
 
282
    """
176
283
    v = os.environ.get('BZREMAIL')
177
284
    if v:
178
285
        return v.decode(bzrlib.user_encoding)
 
286
 
 
287
    if branch:
 
288
        try:
 
289
            return (branch.controlfile("email", "r") 
 
290
                    .read()
 
291
                    .decode(bzrlib.user_encoding)
 
292
                    .rstrip("\r\n"))
 
293
        except IOError, e:
 
294
            if e.errno != errno.ENOENT:
 
295
                raise
 
296
        except BzrError, e:
 
297
            pass
179
298
    
180
299
    try:
181
300
        return (open(os.path.join(config_dir(), "email"))
193
312
        return None
194
313
 
195
314
 
196
 
def username():
 
315
def username(branch):
197
316
    """Return email-style username.
198
317
 
199
318
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
200
319
 
201
320
    TODO: Check it's reasonably well-formed.
202
321
    """
203
 
    v = _get_user_id()
 
322
    v = _get_user_id(branch)
204
323
    if v:
205
324
        return v
206
325
    
211
330
        return email
212
331
 
213
332
 
214
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
215
 
def user_email():
 
333
def user_email(branch):
216
334
    """Return just the email component of a username."""
217
 
    e = _get_user_id()
 
335
    e = _get_user_id(branch)
218
336
    if e:
219
 
        m = _EMAIL_RE.search(e)
 
337
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
220
338
        if not m:
221
 
            bailout("%r doesn't seem to contain a reasonable email address" % e)
 
339
            raise BzrError("%r doesn't seem to contain "
 
340
                           "a reasonable email address" % e)
222
341
        return m.group(0)
223
342
 
224
343
    return _auto_user_id()[1]
225
 
    
226
344
 
227
345
 
228
346
def compare_files(a, b):
237
355
            return True
238
356
 
239
357
 
240
 
 
241
358
def local_time_offset(t=None):
242
359
    """Return offset of local zone from GMT, either at present or at time t."""
243
360
    # python2.3 localtime() can't take None
266
383
        tt = time.localtime(t)
267
384
        offset = local_time_offset(t)
268
385
    else:
269
 
        bailout("unsupported timezone format %r",
270
 
                ['options are "utc", "original", "local"'])
 
386
        raise BzrError("unsupported timezone format %r" % timezone,
 
387
                       ['options are "utc", "original", "local"'])
271
388
 
272
389
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
273
390
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
282
399
    """Return size of given open file."""
283
400
    return os.fstat(f.fileno())[ST_SIZE]
284
401
 
285
 
 
286
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
402
# Define rand_bytes based on platform.
 
403
try:
 
404
    # Python 2.4 and later have os.urandom,
 
405
    # but it doesn't work on some arches
 
406
    os.urandom(1)
287
407
    rand_bytes = os.urandom
288
 
else:
289
 
    # FIXME: No good on non-Linux
290
 
    _rand_file = file('/dev/urandom', 'rb')
291
 
    rand_bytes = _rand_file.read
292
 
 
 
408
except (NotImplementedError, AttributeError):
 
409
    # If python doesn't have os.urandom, or it doesn't work,
 
410
    # then try to first pull random data from /dev/urandom
 
411
    if os.path.exists("/dev/urandom"):
 
412
        rand_bytes = file('/dev/urandom', 'rb').read
 
413
    # Otherwise, use this hack as a last resort
 
414
    else:
 
415
        # not well seeded, but better than nothing
 
416
        def rand_bytes(n):
 
417
            import random
 
418
            s = ''
 
419
            while n:
 
420
                s += chr(random.randint(0, 255))
 
421
                n -= 1
 
422
            return s
293
423
 
294
424
## TODO: We could later have path objects that remember their list
295
425
## decomposition (might be too tricksy though.)
308
438
    >>> splitpath('a/../b')
309
439
    Traceback (most recent call last):
310
440
    ...
311
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
441
    BzrError: sorry, '..' not allowed in path
312
442
    """
313
443
    assert isinstance(p, types.StringTypes)
314
444
 
319
449
    rps = []
320
450
    for f in ps:
321
451
        if f == '..':
322
 
            bailout("sorry, %r not allowed in path" % f)
 
452
            raise BzrError("sorry, %r not allowed in path" % f)
323
453
        elif (f == '.') or (f == ''):
324
454
            pass
325
455
        else:
330
460
    assert isinstance(p, list)
331
461
    for f in p:
332
462
        if (f == '..') or (f == None) or (f == ''):
333
 
            bailout("sorry, %r not allowed in path" % f)
 
463
            raise BzrError("sorry, %r not allowed in path" % f)
334
464
    return os.path.join(*p)
335
465
 
336
466
 
345
475
    mutter('external command: %s' % `cmd`)
346
476
    if os.system(cmd):
347
477
        if not ignore_errors:
348
 
            bailout('command failed')
349
 
 
 
478
            raise BzrError('command failed')
 
479
 
 
480
 
 
481
def _read_config_value(name):
 
482
    """Read a config value from the file ~/.bzr.conf/<name>
 
483
    Return None if the file does not exist"""
 
484
    try:
 
485
        f = file(os.path.join(config_dir(), name), "r")
 
486
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
487
    except IOError, e:
 
488
        if e.errno == errno.ENOENT:
 
489
            return None
 
490
        raise