~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Martin Pool
  • Date: 2005-03-15 05:19:54 UTC
  • Revision ID: mbp@sourcefrog.net-20050315051954-e4bdd6dfd26f8ecf
witty comment

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
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.config import config_dir, _get_user_id
33
 
from bzrlib.errors import BzrError
34
 
from bzrlib.trace import mutter
35
 
 
 
19
import os, types, re, time, types
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
 
21
 
 
22
from errors import bailout
36
23
 
37
24
def make_readonly(filename):
38
25
    """Make a filename read-only."""
 
26
    # TODO: probably needs to be fixed for windows
39
27
    mod = os.stat(filename).st_mode
40
28
    mod = mod & 0777555
41
29
    os.chmod(filename, mod)
47
35
    os.chmod(filename, mod)
48
36
 
49
37
 
50
 
_QUOTE_RE = None
51
 
 
52
 
 
 
38
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
53
39
def quotefn(f):
54
 
    """Return a quoted filename filename
55
 
 
56
 
    This previously used backslash quoting, but that works poorly on
57
 
    Windows."""
58
 
    # TODO: I'm not really sure this is the best format either.x
59
 
    global _QUOTE_RE
60
 
    if _QUOTE_RE == None:
61
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
62
 
        
63
 
    if _QUOTE_RE.search(f):
64
 
        return '"' + f + '"'
65
 
    else:
66
 
        return f
 
40
    """Return shell-quoted filename"""
 
41
    ## We could be a bit more terse by using double-quotes etc
 
42
    f = _QUOTE_RE.sub(r'\\\1', f)
 
43
    if f[0] == '~':
 
44
        f[0:1] = r'\~' 
 
45
    return f
67
46
 
68
47
 
69
48
def file_kind(f):
74
53
        return 'directory'
75
54
    elif S_ISLNK(mode):
76
55
        return 'symlink'
77
 
    elif S_ISCHR(mode):
78
 
        return 'chardev'
79
 
    elif S_ISBLK(mode):
80
 
        return 'block'
81
 
    elif S_ISFIFO(mode):
82
 
        return 'fifo'
83
 
    elif S_ISSOCK(mode):
84
 
        return 'socket'
85
 
    else:
86
 
        return 'unknown'
87
 
 
88
 
 
89
 
def kind_marker(kind):
90
 
    if kind == 'file':
91
 
        return ''
92
 
    elif kind == 'directory':
93
 
        return '/'
94
 
    elif kind == 'symlink':
95
 
        return '@'
96
 
    else:
97
 
        raise BzrError('invalid file kind %r' % kind)
98
 
 
99
 
def lexists(f):
100
 
    try:
101
 
        if hasattr(os, 'lstat'):
102
 
            os.lstat(f)
103
 
        else:
104
 
            os.stat(f)
105
 
        return True
106
 
    except OSError,e:
107
 
        if e.errno == errno.ENOENT:
108
 
            return False;
109
 
        else:
110
 
            raise BzrError("lstat/stat of (%r): %r" % (f, e))
111
 
 
112
 
def normalizepath(f):
113
 
    if hasattr(os.path, 'realpath'):
114
 
        F = os.path.realpath
115
 
    else:
116
 
        F = os.path.abspath
117
 
    [p,e] = os.path.split(f)
118
 
    if e == "" or e == "." or e == "..":
119
 
        return F(f)
120
 
    else:
121
 
        return os.path.join(F(p), e)
122
 
    
123
 
 
124
 
def backup_file(fn):
125
 
    """Copy a file to a backup.
126
 
 
127
 
    Backups are named in GNU-style, with a ~ suffix.
128
 
 
129
 
    If the file is already a backup, it's not copied.
130
 
    """
131
 
    if fn[-1] == '~':
132
 
        return
133
 
    bfn = fn + '~'
134
 
 
135
 
    if has_symlinks() and os.path.islink(fn):
136
 
        target = os.readlink(fn)
137
 
        os.symlink(target, bfn)
138
 
        return
139
 
    inf = file(fn, 'rb')
140
 
    try:
141
 
        content = inf.read()
142
 
    finally:
143
 
        inf.close()
144
 
    
145
 
    outf = file(bfn, 'wb')
146
 
    try:
147
 
        outf.write(content)
148
 
    finally:
149
 
        outf.close()
150
 
 
151
 
if os.name == 'nt':
152
 
    import shutil
153
 
    rename = shutil.move
154
 
else:
155
 
    rename = os.rename
 
56
    else:
 
57
        bailout("can't handle file kind with mode %o of %r" % (mode, f)) 
 
58
 
156
59
 
157
60
 
158
61
def isdir(f):
163
66
        return False
164
67
 
165
68
 
 
69
 
166
70
def isfile(f):
167
71
    """True if f is a regular file."""
168
72
    try:
170
74
    except OSError:
171
75
        return False
172
76
 
173
 
def islink(f):
174
 
    """True if f is a symlink."""
175
 
    try:
176
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
177
 
    except OSError:
178
 
        return False
179
 
 
180
 
def is_inside(dir, fname):
181
 
    """True if fname is inside dir.
182
 
    
183
 
    The parameters should typically be passed to os.path.normpath first, so
184
 
    that . and .. and repeated slashes are eliminated, and the separators
185
 
    are canonical for the platform.
186
 
    
187
 
    The empty string as a dir name is taken as top-of-tree and matches 
188
 
    everything.
189
 
    
190
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
191
 
    True
192
 
    >>> is_inside('src', 'srccontrol')
193
 
    False
194
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
195
 
    True
196
 
    >>> is_inside('foo.c', 'foo.c')
197
 
    True
198
 
    >>> is_inside('foo.c', '')
199
 
    False
200
 
    >>> is_inside('', 'foo.c')
201
 
    True
202
 
    """
203
 
    # XXX: Most callers of this can actually do something smarter by 
204
 
    # looking at the inventory
205
 
    if dir == fname:
206
 
        return True
207
 
    
208
 
    if dir == '':
209
 
        return True
210
 
 
211
 
    if dir[-1] != os.sep:
212
 
        dir += os.sep
213
 
 
214
 
    return fname.startswith(dir)
215
 
 
216
 
 
217
 
def is_inside_any(dir_list, fname):
218
 
    """True if fname is inside any of given dirs."""
219
 
    for dirname in dir_list:
220
 
        if is_inside(dirname, fname):
221
 
            return True
222
 
    else:
223
 
        return False
224
 
 
225
77
 
226
78
def pumpfile(fromfile, tofile):
227
79
    """Copy contents of one file to another."""
228
80
    tofile.write(fromfile.read())
229
81
 
230
82
 
 
83
def uuid():
 
84
    """Return a new UUID"""
 
85
    
 
86
    ## XXX: Could alternatively read /proc/sys/kernel/random/uuid on
 
87
    ## Linux, but we need something portable for other systems;
 
88
    ## preferably an implementation in Python.
 
89
    bailout('uuids not allowed!')
 
90
    return chomp(os.popen('uuidgen').readline())
 
91
 
 
92
def chomp(s):
 
93
    if s and (s[-1] == '\n'):
 
94
        return s[:-1]
 
95
    else:
 
96
        return s
 
97
 
 
98
 
231
99
def sha_file(f):
 
100
    import sha
 
101
    ## TODO: Maybe read in chunks to handle big files
232
102
    if hasattr(f, 'tell'):
233
103
        assert f.tell() == 0
234
104
    s = sha.new()
235
 
    BUFSIZE = 128<<10
236
 
    while True:
237
 
        b = f.read(BUFSIZE)
238
 
        if not b:
239
 
            break
240
 
        s.update(b)
241
 
    return s.hexdigest()
242
 
 
243
 
 
244
 
 
245
 
def sha_strings(strings):
246
 
    """Return the sha-1 of concatenation of strings"""
247
 
    s = sha.new()
248
 
    map(s.update, strings)
 
105
    s.update(f.read())
249
106
    return s.hexdigest()
250
107
 
251
108
 
252
109
def sha_string(f):
 
110
    import sha
253
111
    s = sha.new()
254
112
    s.update(f)
255
113
    return s.hexdigest()
256
114
 
257
115
 
258
 
def fingerprint_file(f):
259
 
    s = sha.new()
260
 
    b = f.read()
261
 
    s.update(b)
262
 
    size = len(b)
263
 
    return {'size': size,
264
 
            'sha1': s.hexdigest()}
 
116
 
 
117
def username():
 
118
    """Return email-style username.
 
119
 
 
120
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
121
 
 
122
    :todo: Check it's reasonably well-formed.
 
123
 
 
124
    :todo: Allow taking it from a dotfile to help people on windows
 
125
           who can't easily set variables.
 
126
 
 
127
    :todo: Cope without pwd module, which is only on unix. 
 
128
    """
 
129
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
 
130
    if e: return e
 
131
 
 
132
    import socket
 
133
    
 
134
    try:
 
135
        import pwd
 
136
        uid = os.getuid()
 
137
        w = pwd.getpwuid(uid)
 
138
        gecos = w.pw_gecos
 
139
        comma = gecos.find(',')
 
140
        if comma == -1:
 
141
            realname = gecos
 
142
        else:
 
143
            realname = gecos[:comma]
 
144
        return '%s <%s@%s>' % (realname, w.pw_name, socket.getfqdn())
 
145
    except ImportError:
 
146
        pass
 
147
 
 
148
    import getpass, socket
 
149
    return '<%s@%s>' % (getpass.getuser(), socket.getfqdn())
 
150
 
 
151
 
 
152
def user_email():
 
153
    """Return just the email component of a username."""
 
154
    e = os.environ.get('BZREMAIL') or os.environ.get('EMAIL')
 
155
    if e:
 
156
        import re
 
157
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
158
        if not m:
 
159
            bailout('%r is not a reasonable email address' % e)
 
160
        return m.group(0)
 
161
 
 
162
 
 
163
    import getpass, socket
 
164
    return '%s@%s' % (getpass.getuser(), socket.getfqdn())
 
165
 
 
166
    
265
167
 
266
168
 
267
169
def compare_files(a, b):
268
170
    """Returns true if equal in contents"""
269
 
    BUFSIZE = 4096
270
 
    while True:
271
 
        ai = a.read(BUFSIZE)
272
 
        bi = b.read(BUFSIZE)
273
 
        if ai != bi:
274
 
            return False
275
 
        if ai == '':
276
 
            return True
277
 
 
278
 
 
279
 
def local_time_offset(t=None):
280
 
    """Return offset of local zone from GMT, either at present or at time t."""
281
 
    # python2.3 localtime() can't take None
282
 
    if t == None:
283
 
        t = time.time()
284
 
        
285
 
    if time.localtime(t).tm_isdst and time.daylight:
 
171
    # TODO: don't read the whole thing in one go.
 
172
    result = a.read() == b.read()
 
173
    return result
 
174
 
 
175
 
 
176
 
 
177
def local_time_offset():
 
178
    if time.daylight:
286
179
        return -time.altzone
287
180
    else:
288
181
        return -time.timezone
291
184
def format_date(t, offset=0, timezone='original'):
292
185
    ## TODO: Perhaps a global option to use either universal or local time?
293
186
    ## Or perhaps just let people set $TZ?
 
187
    import time
 
188
    
294
189
    assert isinstance(t, float)
295
190
    
296
191
    if timezone == 'utc':
302
197
        tt = time.gmtime(t + offset)
303
198
    elif timezone == 'local':
304
199
        tt = time.localtime(t)
305
 
        offset = local_time_offset(t)
 
200
        offset = local_time_offset()
306
201
    else:
307
 
        raise BzrError("unsupported timezone format %r" % timezone,
308
 
                       ['options are "utc", "original", "local"'])
 
202
        bailout("unsupported timezone format %r",
 
203
                ['options are "utc", "original", "local"'])
309
204
 
310
205
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
311
206
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
320
215
    """Return size of given open file."""
321
216
    return os.fstat(f.fileno())[ST_SIZE]
322
217
 
323
 
# Define rand_bytes based on platform.
324
 
try:
325
 
    # Python 2.4 and later have os.urandom,
326
 
    # but it doesn't work on some arches
327
 
    os.urandom(1)
 
218
 
 
219
if hasattr(os, 'urandom'): # python 2.4 and later
328
220
    rand_bytes = os.urandom
329
 
except (NotImplementedError, AttributeError):
330
 
    # If python doesn't have os.urandom, or it doesn't work,
331
 
    # then try to first pull random data from /dev/urandom
332
 
    if os.path.exists("/dev/urandom"):
333
 
        rand_bytes = file('/dev/urandom', 'rb').read
334
 
    # Otherwise, use this hack as a last resort
335
 
    else:
336
 
        # not well seeded, but better than nothing
337
 
        def rand_bytes(n):
338
 
            import random
339
 
            s = ''
340
 
            while n:
341
 
                s += chr(random.randint(0, 255))
342
 
                n -= 1
343
 
            return s
 
221
else:
 
222
    # FIXME: No good on non-Linux
 
223
    _rand_file = file('/dev/urandom', 'rb')
 
224
    rand_bytes = _rand_file.read
 
225
 
344
226
 
345
227
## TODO: We could later have path objects that remember their list
346
228
## decomposition (might be too tricksy though.)
359
241
    >>> splitpath('a/../b')
360
242
    Traceback (most recent call last):
361
243
    ...
362
 
    BzrError: sorry, '..' not allowed in path
 
244
    BzrError: ("sorry, '..' not allowed in path", [])
363
245
    """
364
246
    assert isinstance(p, types.StringTypes)
365
 
 
366
 
    # split on either delimiter because people might use either on
367
 
    # Windows
368
 
    ps = re.split(r'[\\/]', p)
369
 
 
370
 
    rps = []
 
247
    ps = [f for f in p.split('/') if f != '.']
371
248
    for f in ps:
372
249
        if f == '..':
373
 
            raise BzrError("sorry, %r not allowed in path" % f)
374
 
        elif (f == '.') or (f == ''):
375
 
            pass
376
 
        else:
377
 
            rps.append(f)
378
 
    return rps
 
250
            bailout("sorry, %r not allowed in path" % f)
 
251
    return ps
379
252
 
380
253
def joinpath(p):
381
254
    assert isinstance(p, list)
382
255
    for f in p:
383
 
        if (f == '..') or (f == None) or (f == ''):
384
 
            raise BzrError("sorry, %r not allowed in path" % f)
385
 
    return os.path.join(*p)
 
256
        if (f == '..') or (f is None) or (f == ''):
 
257
            bailout("sorry, %r not allowed in path" % f)
 
258
    return '/'.join(p)
386
259
 
387
260
 
388
261
def appendpath(p1, p2):
389
262
    if p1 == '':
390
263
        return p2
391
264
    else:
392
 
        return os.path.join(p1, p2)
 
265
        return p1 + '/' + p2
393
266
    
394
267
 
395
 
def split_lines(s):
396
 
    """Split s into lines, but without removing the newline characters."""
397
 
    return StringIO(s).readlines()
398
 
 
399
 
 
400
 
def hardlinks_good():
401
 
    return sys.platform not in ('win32', 'cygwin', 'darwin')
402
 
 
403
 
 
404
 
def link_or_copy(src, dest):
405
 
    """Hardlink a file, or copy it if it can't be hardlinked."""
406
 
    if not hardlinks_good():
407
 
        copyfile(src, dest)
408
 
        return
409
 
    try:
410
 
        os.link(src, dest)
411
 
    except (OSError, IOError), e:
412
 
        if e.errno != errno.EXDEV:
413
 
            raise
414
 
        copyfile(src, dest)
415
 
 
416
 
 
417
 
def has_symlinks():
418
 
    if hasattr(os, 'symlink'):
419
 
        return True
420
 
    else:
421
 
        return False
 
268
def extern_command(cmd, ignore_errors = False):
 
269
    mutter('external command: %s' % `cmd`)
 
270
    if os.system(cmd):
 
271
        if not ignore_errors:
 
272
            bailout('command failed')
 
273