~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2005-09-28 04:58:18 UTC
  • mto: (1092.2.19)
  • mto: This revision was merged to the branch mainline in revision 1391.
  • Revision ID: robertc@robertcollins.net-20050928045818-c5ce6c7cc796f6fc
patch from Rob Weir to correct bzr-man.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
19
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
21
20
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
22
 
from cStringIO import StringIO
23
21
import errno
24
22
import os
25
23
import re
26
24
import sha
27
 
import string
28
25
import sys
29
26
import time
30
27
import types
31
28
 
32
29
import bzrlib
33
 
from bzrlib.errors import BzrError, NotBranchError
 
30
from bzrlib.errors import BzrError
34
31
from bzrlib.trace import mutter
35
32
 
36
33
 
96
93
    else:
97
94
        raise BzrError('invalid file kind %r' % kind)
98
95
 
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
138
96
 
139
97
def backup_file(fn):
140
98
    """Copy a file to a backup.
147
105
        return
148
106
    bfn = fn + '~'
149
107
 
150
 
    if has_symlinks() and os.path.islink(fn):
151
 
        target = os.readlink(fn)
152
 
        os.symlink(target, bfn)
153
 
        return
154
108
    inf = file(fn, 'rb')
155
109
    try:
156
110
        content = inf.read()
185
139
    except OSError:
186
140
        return False
187
141
 
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
142
 
195
143
def is_inside(dir, fname):
196
144
    """True if fname is inside dir.
256
204
    return s.hexdigest()
257
205
 
258
206
 
259
 
 
260
 
def sha_strings(strings):
261
 
    """Return the sha-1 of concatenation of strings"""
262
 
    s = sha.new()
263
 
    map(s.update, strings)
264
 
    return s.hexdigest()
265
 
 
266
 
 
267
207
def sha_string(f):
268
208
    s = sha.new()
269
209
    s.update(f)
279
219
            'sha1': s.hexdigest()}
280
220
 
281
221
 
 
222
def config_dir():
 
223
    """Return per-user configuration directory.
 
224
 
 
225
    By default this is ~/.bzr.conf/
 
226
    
 
227
    TODO: Global option --config-dir to override this.
 
228
    """
 
229
    return os.path.join(os.path.expanduser("~"), ".bzr.conf")
 
230
 
 
231
 
 
232
def _auto_user_id():
 
233
    """Calculate automatic user identification.
 
234
 
 
235
    Returns (realname, email).
 
236
 
 
237
    Only used when none is set in the environment or the id file.
 
238
 
 
239
    This previously used the FQDN as the default domain, but that can
 
240
    be very slow on machines where DNS is broken.  So now we simply
 
241
    use the hostname.
 
242
    """
 
243
    import socket
 
244
 
 
245
    # XXX: Any good way to get real user name on win32?
 
246
 
 
247
    try:
 
248
        import pwd
 
249
        uid = os.getuid()
 
250
        w = pwd.getpwuid(uid)
 
251
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
252
        username = w.pw_name.decode(bzrlib.user_encoding)
 
253
        comma = gecos.find(',')
 
254
        if comma == -1:
 
255
            realname = gecos
 
256
        else:
 
257
            realname = gecos[:comma]
 
258
        if not realname:
 
259
            realname = username
 
260
 
 
261
    except ImportError:
 
262
        import getpass
 
263
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
264
 
 
265
    return realname, (username + '@' + socket.gethostname())
 
266
 
 
267
 
 
268
def _get_user_id(branch):
 
269
    """Return the full user id from a file or environment variable.
 
270
 
 
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
    """
 
283
    v = os.environ.get('BZREMAIL')
 
284
    if v:
 
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
 
298
    
 
299
    try:
 
300
        return (open(os.path.join(config_dir(), "email"))
 
301
                .read()
 
302
                .decode(bzrlib.user_encoding)
 
303
                .rstrip("\r\n"))
 
304
    except IOError, e:
 
305
        if e.errno != errno.ENOENT:
 
306
            raise e
 
307
 
 
308
    v = os.environ.get('EMAIL')
 
309
    if v:
 
310
        return v.decode(bzrlib.user_encoding)
 
311
    else:    
 
312
        return None
 
313
 
 
314
 
 
315
def username(branch):
 
316
    """Return email-style username.
 
317
 
 
318
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
 
319
 
 
320
    TODO: Check it's reasonably well-formed.
 
321
    """
 
322
    v = _get_user_id(branch)
 
323
    if v:
 
324
        return v
 
325
    
 
326
    name, email = _auto_user_id()
 
327
    if name:
 
328
        return '%s <%s>' % (name, email)
 
329
    else:
 
330
        return email
 
331
 
 
332
 
 
333
def user_email(branch):
 
334
    """Return just the email component of a username."""
 
335
    e = _get_user_id(branch)
 
336
    if e:
 
337
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
338
        if not m:
 
339
            raise BzrError("%r doesn't seem to contain "
 
340
                           "a reasonable email address" % e)
 
341
        return m.group(0)
 
342
 
 
343
    return _auto_user_id()[1]
 
344
 
 
345
 
282
346
def compare_files(a, b):
283
347
    """Returns true if equal in contents"""
284
348
    BUFSIZE = 4096
303
367
        return -time.timezone
304
368
 
305
369
    
306
 
def format_date(t, offset=0, timezone='original', date_fmt=None, 
307
 
                show_offset=True):
 
370
def format_date(t, offset=0, timezone='original'):
308
371
    ## TODO: Perhaps a global option to use either universal or local time?
309
372
    ## Or perhaps just let people set $TZ?
310
373
    assert isinstance(t, float)
322
385
    else:
323
386
        raise BzrError("unsupported timezone format %r" % timezone,
324
387
                       ['options are "utc", "original", "local"'])
325
 
    if date_fmt is None:
326
 
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
327
 
    if show_offset:
328
 
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
329
 
    else:
330
 
        offset_str = ''
331
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
388
 
 
389
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
 
390
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
332
391
 
333
392
 
334
393
def compact_date(when):
412
471
        return os.path.join(p1, p2)
413
472
    
414
473
 
415
 
def split_lines(s):
416
 
    """Split s into lines, but without removing the newline characters."""
417
 
    return StringIO(s).readlines()
418
 
 
419
 
 
420
 
def hardlinks_good():
421
 
    return sys.platform not in ('win32', 'cygwin', 'darwin')
422
 
 
423
 
 
424
 
def link_or_copy(src, dest):
425
 
    """Hardlink a file, or copy it if it can't be hardlinked."""
426
 
    if not hardlinks_good():
427
 
        copyfile(src, dest)
428
 
        return
 
474
def extern_command(cmd, ignore_errors = False):
 
475
    mutter('external command: %s' % `cmd`)
 
476
    if os.system(cmd):
 
477
        if not ignore_errors:
 
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"""
429
484
    try:
430
 
        os.link(src, dest)
431
 
    except (OSError, IOError), e:
432
 
        if e.errno != errno.EXDEV:
433
 
            raise
434
 
        copyfile(src, dest)
435
 
 
436
 
 
437
 
def has_symlinks():
438
 
    if hasattr(os, 'symlink'):
439
 
        return True
440
 
    else:
441
 
        return False
442
 
        
443
 
 
444
 
def contains_whitespace(s):
445
 
    """True if there are any whitespace characters in s."""
446
 
    for ch in string.whitespace:
447
 
        if ch in s:
448
 
            return True
449
 
    else:
450
 
        return False
451
 
 
452
 
 
453
 
def contains_linebreaks(s):
454
 
    """True if there is any vertical whitespace in s."""
455
 
    for ch in '\f\n\r':
456
 
        if ch in s:
457
 
            return True
458
 
    else:
459
 
        return False
460
 
 
461
 
 
462
 
def relpath(base, path):
463
 
    """Return path relative to base, or raise exception.
464
 
 
465
 
    The path may be either an absolute path or a path relative to the
466
 
    current working directory.
467
 
 
468
 
    os.path.commonprefix (python2.4) has a bad bug that it works just
469
 
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
470
 
    avoids that problem."""
471
 
    rp = abspath(path)
472
 
 
473
 
    s = []
474
 
    head = rp
475
 
    while len(head) >= len(base):
476
 
        if head == base:
477
 
            break
478
 
        head, tail = os.path.split(head)
479
 
        if tail:
480
 
            s.insert(0, tail)
481
 
    else:
482
 
        # XXX This should raise a NotChildPath exception, as its not tied
483
 
        # to branch anymore.
484
 
        raise NotBranchError("path %r is not within branch %r" % (rp, base))
485
 
 
486
 
    return os.sep.join(s)
 
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