~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

Lalo Martins remotebranch patch

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 string
28
 
import sys
29
 
import time
30
 
import types
 
19
import os, types, re, time, errno, sys
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
31
21
 
 
22
from bzrlib.errors import BzrError
 
23
from bzrlib.trace import mutter
32
24
import bzrlib
33
 
from bzrlib.errors import BzrError, NotBranchError
34
 
from bzrlib.trace import mutter
35
 
 
36
25
 
37
26
def make_readonly(filename):
38
27
    """Make a filename read-only."""
 
28
    # TODO: probably needs to be fixed for windows
39
29
    mod = os.stat(filename).st_mode
40
30
    mod = mod & 0777555
41
31
    os.chmod(filename, mod)
58
48
    # TODO: I'm not really sure this is the best format either.x
59
49
    global _QUOTE_RE
60
50
    if _QUOTE_RE == None:
61
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
51
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
62
52
        
63
53
    if _QUOTE_RE.search(f):
64
54
        return '"' + f + '"'
74
64
        return 'directory'
75
65
    elif S_ISLNK(mode):
76
66
        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
67
    else:
86
 
        return 'unknown'
 
68
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
87
69
 
88
70
 
89
71
def kind_marker(kind):
96
78
    else:
97
79
        raise BzrError('invalid file kind %r' % kind)
98
80
 
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
 
if os.name == "posix":
124
 
    # In Python 2.4.2 and older, os.path.abspath and os.path.realpath
125
 
    # choke on a Unicode string containing a relative path if
126
 
    # os.getcwd() returns a non-sys.getdefaultencoding()-encoded
127
 
    # string.
128
 
    _fs_enc = sys.getfilesystemencoding()
129
 
    def abspath(path):
130
 
        return os.path.abspath(path.encode(_fs_enc)).decode(_fs_enc)
131
 
    def realpath(path):
132
 
        return os.path.realpath(path.encode(_fs_enc)).decode(_fs_enc)
133
 
else:
134
 
    # We need to use the Unicode-aware os.path.abspath and
135
 
    # os.path.realpath on Windows systems.
136
 
    abspath = os.path.abspath
137
 
    realpath = os.path.realpath
 
81
 
138
82
 
139
83
def backup_file(fn):
140
84
    """Copy a file to a backup.
143
87
 
144
88
    If the file is already a backup, it's not copied.
145
89
    """
 
90
    import os
146
91
    if fn[-1] == '~':
147
92
        return
148
93
    bfn = fn + '~'
149
94
 
150
 
    if has_symlinks() and os.path.islink(fn):
151
 
        target = os.readlink(fn)
152
 
        os.symlink(target, bfn)
153
 
        return
154
95
    inf = file(fn, 'rb')
155
96
    try:
156
97
        content = inf.read()
163
104
    finally:
164
105
        outf.close()
165
106
 
166
 
if os.name == 'nt':
167
 
    import shutil
168
 
    rename = shutil.move
169
 
else:
170
 
    rename = os.rename
 
107
def rename(path_from, path_to):
 
108
    """Basically the same as os.rename() just special for win32"""
 
109
    if sys.platform == 'win32':
 
110
        try:
 
111
            os.remove(path_to)
 
112
        except OSError, e:
 
113
            if e.errno != e.ENOENT:
 
114
                raise
 
115
    os.rename(path_from, path_to)
 
116
 
 
117
 
 
118
 
171
119
 
172
120
 
173
121
def isdir(f):
178
126
        return False
179
127
 
180
128
 
 
129
 
181
130
def isfile(f):
182
131
    """True if f is a regular file."""
183
132
    try:
185
134
    except OSError:
186
135
        return False
187
136
 
188
 
def islink(f):
189
 
    """True if f is a symlink."""
190
 
    try:
191
 
        return S_ISLNK(os.lstat(f)[ST_MODE])
192
 
    except OSError:
193
 
        return False
194
137
 
195
138
def is_inside(dir, fname):
196
139
    """True if fname is inside dir.
202
145
    The empty string as a dir name is taken as top-of-tree and matches 
203
146
    everything.
204
147
    
205
 
    >>> is_inside('src', os.path.join('src', 'foo.c'))
 
148
    >>> is_inside('src', 'src/foo.c')
206
149
    True
207
150
    >>> is_inside('src', 'srccontrol')
208
151
    False
209
 
    >>> is_inside('src', os.path.join('src', 'a', 'a', 'a', 'foo.c'))
 
152
    >>> is_inside('src', 'src/a/a/a/foo.c')
210
153
    True
211
154
    >>> is_inside('foo.c', 'foo.c')
212
155
    True
222
165
    
223
166
    if dir == '':
224
167
        return True
225
 
 
 
168
    
226
169
    if dir[-1] != os.sep:
227
170
        dir += os.sep
228
 
 
 
171
    
229
172
    return fname.startswith(dir)
230
173
 
231
174
 
240
183
 
241
184
def pumpfile(fromfile, tofile):
242
185
    """Copy contents of one file to another."""
243
 
    BUFSIZE = 32768
244
 
    while True:
245
 
        b = fromfile.read(BUFSIZE)
246
 
        if not b:
247
 
            break
248
 
        tofile.write(b)
 
186
    tofile.write(fromfile.read())
 
187
 
 
188
 
 
189
def uuid():
 
190
    """Return a new UUID"""
 
191
    try:
 
192
        return file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
 
193
    except IOError:
 
194
        return chomp(os.popen('uuidgen').readline())
249
195
 
250
196
 
251
197
def sha_file(f):
 
198
    import sha
252
199
    if hasattr(f, 'tell'):
253
200
        assert f.tell() == 0
254
201
    s = sha.new()
261
208
    return s.hexdigest()
262
209
 
263
210
 
264
 
 
265
 
def sha_strings(strings):
266
 
    """Return the sha-1 of concatenation of strings"""
267
 
    s = sha.new()
268
 
    map(s.update, strings)
269
 
    return s.hexdigest()
270
 
 
271
 
 
272
211
def sha_string(f):
 
212
    import sha
273
213
    s = sha.new()
274
214
    s.update(f)
275
215
    return s.hexdigest()
276
216
 
277
217
 
 
218
 
278
219
def fingerprint_file(f):
 
220
    import sha
279
221
    s = sha.new()
280
222
    b = f.read()
281
223
    s.update(b)
284
226
            'sha1': s.hexdigest()}
285
227
 
286
228
 
 
229
def config_dir():
 
230
    """Return per-user configuration directory.
 
231
 
 
232
    By default this is ~/.bzr.conf/
 
233
    
 
234
    TODO: Global option --config-dir to override this.
 
235
    """
 
236
    return os.path.expanduser("~/.bzr.conf")
 
237
 
 
238
 
 
239
def _auto_user_id():
 
240
    """Calculate automatic user identification.
 
241
 
 
242
    Returns (realname, email).
 
243
 
 
244
    Only used when none is set in the environment or the id file.
 
245
 
 
246
    This previously used the FQDN as the default domain, but that can
 
247
    be very slow on machines where DNS is broken.  So now we simply
 
248
    use the hostname.
 
249
    """
 
250
    import socket
 
251
 
 
252
    # XXX: Any good way to get real user name on win32?
 
253
 
 
254
    try:
 
255
        import pwd
 
256
        uid = os.getuid()
 
257
        w = pwd.getpwuid(uid)
 
258
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
259
        username = w.pw_name.decode(bzrlib.user_encoding)
 
260
        comma = gecos.find(',')
 
261
        if comma == -1:
 
262
            realname = gecos
 
263
        else:
 
264
            realname = gecos[:comma]
 
265
        if not realname:
 
266
            realname = username
 
267
 
 
268
    except ImportError:
 
269
        import getpass
 
270
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
271
 
 
272
    return realname, (username + '@' + socket.gethostname())
 
273
 
 
274
 
 
275
def _get_user_id(branch):
 
276
    """Return the full user id from a file or environment variable.
 
277
 
 
278
    e.g. "John Hacker <jhacker@foo.org>"
 
279
 
 
280
    branch
 
281
        A branch to use for a per-branch configuration, or None.
 
282
 
 
283
    The following are searched in order:
 
284
 
 
285
    1. $BZREMAIL
 
286
    2. .bzr/email for this branch.
 
287
    3. ~/.bzr.conf/email
 
288
    4. $EMAIL
 
289
    """
 
290
    v = os.environ.get('BZREMAIL')
 
291
    if v:
 
292
        return v.decode(bzrlib.user_encoding)
 
293
 
 
294
    if branch:
 
295
        try:
 
296
            return (branch.controlfile("email", "r") 
 
297
                    .read()
 
298
                    .decode(bzrlib.user_encoding)
 
299
                    .rstrip("\r\n"))
 
300
        except IOError, e:
 
301
            if e.errno != errno.ENOENT:
 
302
                raise
 
303
        except BzrError, e:
 
304
            pass
 
305
    
 
306
    try:
 
307
        return (open(os.path.join(config_dir(), "email"))
 
308
                .read()
 
309
                .decode(bzrlib.user_encoding)
 
310
                .rstrip("\r\n"))
 
311
    except IOError, e:
 
312
        if e.errno != errno.ENOENT:
 
313
            raise e
 
314
 
 
315
    v = os.environ.get('EMAIL')
 
316
    if v:
 
317
        return v.decode(bzrlib.user_encoding)
 
318
    else:    
 
319
        return None
 
320
 
 
321
 
 
322
def username(branch):
 
323
    """Return email-style username.
 
324
 
 
325
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
326
 
 
327
    TODO: Check it's reasonably well-formed.
 
328
    """
 
329
    v = _get_user_id(branch)
 
330
    if v:
 
331
        return v
 
332
    
 
333
    name, email = _auto_user_id()
 
334
    if name:
 
335
        return '%s <%s>' % (name, email)
 
336
    else:
 
337
        return email
 
338
 
 
339
 
 
340
def user_email(branch):
 
341
    """Return just the email component of a username."""
 
342
    e = _get_user_id(branch)
 
343
    if e:
 
344
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
345
        if not m:
 
346
            raise BzrError("%r doesn't seem to contain a reasonable email address" % e)
 
347
        return m.group(0)
 
348
 
 
349
    return _auto_user_id()[1]
 
350
    
 
351
 
 
352
 
287
353
def compare_files(a, b):
288
354
    """Returns true if equal in contents"""
289
355
    BUFSIZE = 4096
296
362
            return True
297
363
 
298
364
 
 
365
 
299
366
def local_time_offset(t=None):
300
367
    """Return offset of local zone from GMT, either at present or at time t."""
301
368
    # python2.3 localtime() can't take None
308
375
        return -time.timezone
309
376
 
310
377
    
311
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
312
 
                show_offset=True):
 
378
def format_date(t, offset=0, timezone='original'):
313
379
    ## TODO: Perhaps a global option to use either universal or local time?
314
380
    ## Or perhaps just let people set $TZ?
315
381
    assert isinstance(t, float)
327
393
    else:
328
394
        raise BzrError("unsupported timezone format %r" % timezone,
329
395
                       ['options are "utc", "original", "local"'])
330
 
    if date_fmt is None:
331
 
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
332
 
    if show_offset:
333
 
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
334
 
    else:
335
 
        offset_str = ''
336
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
396
 
 
397
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
398
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
337
399
 
338
400
 
339
401
def compact_date(when):
417
479
        return os.path.join(p1, p2)
418
480
    
419
481
 
420
 
def split_lines(s):
421
 
    """Split s into lines, but without removing the newline characters."""
422
 
    return StringIO(s).readlines()
423
 
 
424
 
 
425
 
def hardlinks_good():
426
 
    return sys.platform not in ('win32', 'cygwin', 'darwin')
427
 
 
428
 
 
429
 
def link_or_copy(src, dest):
430
 
    """Hardlink a file, or copy it if it can't be hardlinked."""
431
 
    if not hardlinks_good():
432
 
        copyfile(src, dest)
433
 
        return
434
 
    try:
435
 
        os.link(src, dest)
436
 
    except (OSError, IOError), e:
437
 
        if e.errno != errno.EXDEV:
438
 
            raise
439
 
        copyfile(src, dest)
440
 
 
441
 
 
442
 
def has_symlinks():
443
 
    if hasattr(os, 'symlink'):
444
 
        return True
445
 
    else:
446
 
        return False
447
 
        
448
 
 
449
 
def contains_whitespace(s):
450
 
    """True if there are any whitespace characters in s."""
451
 
    for ch in string.whitespace:
452
 
        if ch in s:
453
 
            return True
454
 
    else:
455
 
        return False
456
 
 
457
 
 
458
 
def contains_linebreaks(s):
459
 
    """True if there is any vertical whitespace in s."""
460
 
    for ch in '\f\n\r':
461
 
        if ch in s:
462
 
            return True
463
 
    else:
464
 
        return False
465
 
 
466
 
 
467
 
def relpath(base, path):
468
 
    """Return path relative to base, or raise exception.
469
 
 
470
 
    The path may be either an absolute path or a path relative to the
471
 
    current working directory.
472
 
 
473
 
    os.path.commonprefix (python2.4) has a bad bug that it works just
474
 
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
475
 
    avoids that problem."""
476
 
    rp = abspath(path)
477
 
 
478
 
    s = []
479
 
    head = rp
480
 
    while len(head) >= len(base):
481
 
        if head == base:
482
 
            break
483
 
        head, tail = os.path.split(head)
484
 
        if tail:
485
 
            s.insert(0, tail)
486
 
    else:
487
 
        # XXX This should raise a NotChildPath exception, as its not tied
488
 
        # to branch anymore.
489
 
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
490
 
 
491
 
    return os.sep.join(s)
492
 
 
493
 
 
494
 
 
495
 
def terminal_width():
496
 
    """Return estimated terminal width."""
497
 
 
498
 
    # TODO: Do something smart on Windows?
499
 
 
500
 
    # TODO: Is there anything that gets a better update when the window
501
 
    # is resized while the program is running? We could use the Python termcap
502
 
    # library.
503
 
    try:
504
 
        return int(os.environ['COLUMNS'])
505
 
    except (IndexError, KeyError, ValueError):
506
 
        return 80
 
482
def extern_command(cmd, ignore_errors = False):
 
483
    mutter('external command: %s' % `cmd`)
 
484
    if os.system(cmd):
 
485
        if not ignore_errors:
 
486
            raise BzrError('command failed')
 
487
 
 
488
 
 
489
def _read_config_value(name):
 
490
    """Read a config value from the file ~/.bzr.conf/<name>
 
491
    Return None if the file does not exist"""
 
492
    try:
 
493
        f = file(os.path.join(config_dir(), name), "r")
 
494
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
 
495
    except IOError, e:
 
496
        if e.errno == errno.ENOENT:
 
497
            return None
 
498
        raise
 
499
 
 
500