~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Aaron Bentley
  • Date: 2006-08-16 19:13:00 UTC
  • mfrom: (1934 +trunk)
  • mto: (1910.2.43 format-bumps)
  • mto: This revision was merged to the branch mainline in revision 1935.
  • Revision ID: abentley@panoramicfeedback.com-20060816191300-045772b26b975d1c
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Bazaar-NG -- distributed version control
2
 
 
 
1
# Bazaar -- distributed version control
 
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 cStringIO import StringIO
 
20
import errno
 
21
from ntpath import (abspath as _nt_abspath,
 
22
                    join as _nt_join,
 
23
                    normpath as _nt_normpath,
 
24
                    realpath as _nt_realpath,
 
25
                    splitdrive as _nt_splitdrive,
 
26
                    )
 
27
import os
 
28
from os import listdir
 
29
import posixpath
 
30
import re
 
31
import sha
 
32
import shutil
 
33
from shutil import copyfile
 
34
import stat
 
35
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
 
36
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
37
import string
 
38
import sys
 
39
import time
 
40
import types
 
41
import tempfile
 
42
import unicodedata
21
43
 
22
 
from errors import bailout, BzrError
23
 
from trace import mutter
24
44
import bzrlib
 
45
from bzrlib.errors import (BzrError,
 
46
                           BzrBadParameterNotUnicode,
 
47
                           NoSuchFile,
 
48
                           PathNotChild,
 
49
                           IllegalPath,
 
50
                           )
 
51
from bzrlib.symbol_versioning import (deprecated_function, 
 
52
        zero_nine)
 
53
from bzrlib.trace import mutter
 
54
 
 
55
 
 
56
# On win32, O_BINARY is used to indicate the file should
 
57
# be opened in binary mode, rather than text mode.
 
58
# On other platforms, O_BINARY doesn't exist, because
 
59
# they always open in binary mode, so it is okay to
 
60
# OR with 0 on those platforms
 
61
O_BINARY = getattr(os, 'O_BINARY', 0)
 
62
 
25
63
 
26
64
def make_readonly(filename):
27
65
    """Make a filename read-only."""
28
 
    # TODO: probably needs to be fixed for windows
29
66
    mod = os.stat(filename).st_mode
30
67
    mod = mod & 0777555
31
68
    os.chmod(filename, mod)
37
74
    os.chmod(filename, mod)
38
75
 
39
76
 
40
 
_QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
77
_QUOTE_RE = None
 
78
 
 
79
 
41
80
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
48
 
 
49
 
 
50
 
def file_kind(f):
51
 
    mode = os.lstat(f)[ST_MODE]
52
 
    if S_ISREG(mode):
53
 
        return 'file'
54
 
    elif S_ISDIR(mode):
55
 
        return 'directory'
56
 
    elif S_ISLNK(mode):
57
 
        return 'symlink'
58
 
    else:
59
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f)) 
60
 
 
 
81
    """Return a quoted filename filename
 
82
 
 
83
    This previously used backslash quoting, but that works poorly on
 
84
    Windows."""
 
85
    # TODO: I'm not really sure this is the best format either.x
 
86
    global _QUOTE_RE
 
87
    if _QUOTE_RE == None:
 
88
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
 
89
        
 
90
    if _QUOTE_RE.search(f):
 
91
        return '"' + f + '"'
 
92
    else:
 
93
        return f
 
94
 
 
95
 
 
96
_directory_kind = 'directory'
 
97
 
 
98
_formats = {
 
99
    stat.S_IFDIR:_directory_kind,
 
100
    stat.S_IFCHR:'chardev',
 
101
    stat.S_IFBLK:'block',
 
102
    stat.S_IFREG:'file',
 
103
    stat.S_IFIFO:'fifo',
 
104
    stat.S_IFLNK:'symlink',
 
105
    stat.S_IFSOCK:'socket',
 
106
}
 
107
 
 
108
 
 
109
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
 
110
    """Generate a file kind from a stat mode. This is used in walkdirs.
 
111
 
 
112
    Its performance is critical: Do not mutate without careful benchmarking.
 
113
    """
 
114
    try:
 
115
        return _formats[stat_mode & 0170000]
 
116
    except KeyError:
 
117
        return _unknown
 
118
 
 
119
 
 
120
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
 
121
    try:
 
122
        return _mapper(_lstat(f).st_mode)
 
123
    except OSError, e:
 
124
        if getattr(e, 'errno', None) == errno.ENOENT:
 
125
            raise bzrlib.errors.NoSuchFile(f)
 
126
        raise
 
127
 
 
128
 
 
129
def get_umask():
 
130
    """Return the current umask"""
 
131
    # Assume that people aren't messing with the umask while running
 
132
    # XXX: This is not thread safe, but there is no way to get the
 
133
    #      umask without setting it
 
134
    umask = os.umask(0)
 
135
    os.umask(umask)
 
136
    return umask
 
137
 
 
138
 
 
139
def kind_marker(kind):
 
140
    if kind == 'file':
 
141
        return ''
 
142
    elif kind == _directory_kind:
 
143
        return '/'
 
144
    elif kind == 'symlink':
 
145
        return '@'
 
146
    else:
 
147
        raise BzrError('invalid file kind %r' % kind)
 
148
 
 
149
lexists = getattr(os.path, 'lexists', None)
 
150
if lexists is None:
 
151
    def lexists(f):
 
152
        try:
 
153
            if hasattr(os, 'lstat'):
 
154
                os.lstat(f)
 
155
            else:
 
156
                os.stat(f)
 
157
            return True
 
158
        except OSError,e:
 
159
            if e.errno == errno.ENOENT:
 
160
                return False;
 
161
            else:
 
162
                raise BzrError("lstat/stat of (%r): %r" % (f, e))
 
163
 
 
164
 
 
165
def fancy_rename(old, new, rename_func, unlink_func):
 
166
    """A fancy rename, when you don't have atomic rename.
 
167
    
 
168
    :param old: The old path, to rename from
 
169
    :param new: The new path, to rename to
 
170
    :param rename_func: The potentially non-atomic rename function
 
171
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
172
    """
 
173
 
 
174
    # sftp rename doesn't allow overwriting, so play tricks:
 
175
    import random
 
176
    base = os.path.basename(new)
 
177
    dirname = os.path.dirname(new)
 
178
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
179
    tmp_name = pathjoin(dirname, tmp_name)
 
180
 
 
181
    # Rename the file out of the way, but keep track if it didn't exist
 
182
    # We don't want to grab just any exception
 
183
    # something like EACCES should prevent us from continuing
 
184
    # The downside is that the rename_func has to throw an exception
 
185
    # with an errno = ENOENT, or NoSuchFile
 
186
    file_existed = False
 
187
    try:
 
188
        rename_func(new, tmp_name)
 
189
    except (NoSuchFile,), e:
 
190
        pass
 
191
    except IOError, e:
 
192
        # RBC 20060103 abstraction leakage: the paramiko SFTP clients rename
 
193
        # function raises an IOError with errno == None when a rename fails.
 
194
        # This then gets caught here.
 
195
        if e.errno not in (None, errno.ENOENT, errno.ENOTDIR):
 
196
            raise
 
197
    except Exception, e:
 
198
        if (not hasattr(e, 'errno') 
 
199
            or e.errno not in (errno.ENOENT, errno.ENOTDIR)):
 
200
            raise
 
201
    else:
 
202
        file_existed = True
 
203
 
 
204
    success = False
 
205
    try:
 
206
        # This may throw an exception, in which case success will
 
207
        # not be set.
 
208
        rename_func(old, new)
 
209
        success = True
 
210
    finally:
 
211
        if file_existed:
 
212
            # If the file used to exist, rename it back into place
 
213
            # otherwise just delete it from the tmp location
 
214
            if success:
 
215
                unlink_func(tmp_name)
 
216
            else:
 
217
                rename_func(tmp_name, new)
 
218
 
 
219
 
 
220
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
 
221
# choke on a Unicode string containing a relative path if
 
222
# os.getcwd() returns a non-sys.getdefaultencoding()-encoded
 
223
# string.
 
224
_fs_enc = sys.getfilesystemencoding()
 
225
def _posix_abspath(path):
 
226
    # jam 20060426 rather than encoding to fsencoding
 
227
    # copy posixpath.abspath, but use os.getcwdu instead
 
228
    if not posixpath.isabs(path):
 
229
        path = posixpath.join(getcwd(), path)
 
230
    return posixpath.normpath(path)
 
231
 
 
232
 
 
233
def _posix_realpath(path):
 
234
    return posixpath.realpath(path.encode(_fs_enc)).decode(_fs_enc)
 
235
 
 
236
 
 
237
def _win32_fixdrive(path):
 
238
    """Force drive letters to be consistent.
 
239
 
 
240
    win32 is inconsistent whether it returns lower or upper case
 
241
    and even if it was consistent the user might type the other
 
242
    so we force it to uppercase
 
243
    running python.exe under cmd.exe return capital C:\\
 
244
    running win32 python inside a cygwin shell returns lowercase c:\\
 
245
    """
 
246
    drive, path = _nt_splitdrive(path)
 
247
    return drive.upper() + path
 
248
 
 
249
 
 
250
def _win32_abspath(path):
 
251
    # Real _nt_abspath doesn't have a problem with a unicode cwd
 
252
    return _win32_fixdrive(_nt_abspath(unicode(path)).replace('\\', '/'))
 
253
 
 
254
 
 
255
def _win32_realpath(path):
 
256
    # Real _nt_realpath doesn't have a problem with a unicode cwd
 
257
    return _win32_fixdrive(_nt_realpath(unicode(path)).replace('\\', '/'))
 
258
 
 
259
 
 
260
def _win32_pathjoin(*args):
 
261
    return _nt_join(*args).replace('\\', '/')
 
262
 
 
263
 
 
264
def _win32_normpath(path):
 
265
    return _win32_fixdrive(_nt_normpath(unicode(path)).replace('\\', '/'))
 
266
 
 
267
 
 
268
def _win32_getcwd():
 
269
    return _win32_fixdrive(os.getcwdu().replace('\\', '/'))
 
270
 
 
271
 
 
272
def _win32_mkdtemp(*args, **kwargs):
 
273
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
 
274
 
 
275
 
 
276
def _win32_rename(old, new):
 
277
    """We expect to be able to atomically replace 'new' with old.
 
278
 
 
279
    On win32, if new exists, it must be moved out of the way first,
 
280
    and then deleted. 
 
281
    """
 
282
    try:
 
283
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
284
    except OSError, e:
 
285
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
 
286
            # If we try to rename a non-existant file onto cwd, we get 
 
287
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
 
288
            # if the old path doesn't exist, sometimes we get EACCES
 
289
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
 
290
            os.lstat(old)
 
291
        raise
 
292
 
 
293
 
 
294
def _mac_getcwd():
 
295
    return unicodedata.normalize('NFKC', os.getcwdu())
 
296
 
 
297
 
 
298
# Default is to just use the python builtins, but these can be rebound on
 
299
# particular platforms.
 
300
abspath = _posix_abspath
 
301
realpath = _posix_realpath
 
302
pathjoin = os.path.join
 
303
normpath = os.path.normpath
 
304
getcwd = os.getcwdu
 
305
mkdtemp = tempfile.mkdtemp
 
306
rename = os.rename
 
307
dirname = os.path.dirname
 
308
basename = os.path.basename
 
309
rmtree = shutil.rmtree
 
310
 
 
311
MIN_ABS_PATHLENGTH = 1
 
312
 
 
313
 
 
314
if sys.platform == 'win32':
 
315
    abspath = _win32_abspath
 
316
    realpath = _win32_realpath
 
317
    pathjoin = _win32_pathjoin
 
318
    normpath = _win32_normpath
 
319
    getcwd = _win32_getcwd
 
320
    mkdtemp = _win32_mkdtemp
 
321
    rename = _win32_rename
 
322
 
 
323
    MIN_ABS_PATHLENGTH = 3
 
324
 
 
325
    def _win32_delete_readonly(function, path, excinfo):
 
326
        """Error handler for shutil.rmtree function [for win32]
 
327
        Helps to remove files and dirs marked as read-only.
 
328
        """
 
329
        type_, value = excinfo[:2]
 
330
        if function in (os.remove, os.rmdir) \
 
331
            and type_ == OSError \
 
332
            and value.errno == errno.EACCES:
 
333
            bzrlib.osutils.make_writable(path)
 
334
            function(path)
 
335
        else:
 
336
            raise
 
337
 
 
338
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
 
339
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
 
340
        return shutil.rmtree(path, ignore_errors, onerror)
 
341
elif sys.platform == 'darwin':
 
342
    getcwd = _mac_getcwd
 
343
 
 
344
 
 
345
def get_terminal_encoding():
 
346
    """Find the best encoding for printing to the screen.
 
347
 
 
348
    This attempts to check both sys.stdout and sys.stdin to see
 
349
    what encoding they are in, and if that fails it falls back to
 
350
    bzrlib.user_encoding.
 
351
    The problem is that on Windows, locale.getpreferredencoding()
 
352
    is not the same encoding as that used by the console:
 
353
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
 
354
 
 
355
    On my standard US Windows XP, the preferred encoding is
 
356
    cp1252, but the console is cp437
 
357
    """
 
358
    output_encoding = getattr(sys.stdout, 'encoding', None)
 
359
    if not output_encoding:
 
360
        input_encoding = getattr(sys.stdin, 'encoding', None)
 
361
        if not input_encoding:
 
362
            output_encoding = bzrlib.user_encoding
 
363
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
364
        else:
 
365
            output_encoding = input_encoding
 
366
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
 
367
    else:
 
368
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
369
    return output_encoding
 
370
 
 
371
 
 
372
def normalizepath(f):
 
373
    if hasattr(os.path, 'realpath'):
 
374
        F = realpath
 
375
    else:
 
376
        F = abspath
 
377
    [p,e] = os.path.split(f)
 
378
    if e == "" or e == "." or e == "..":
 
379
        return F(f)
 
380
    else:
 
381
        return pathjoin(F(p), e)
 
382
 
 
383
 
 
384
def backup_file(fn):
 
385
    """Copy a file to a backup.
 
386
 
 
387
    Backups are named in GNU-style, with a ~ suffix.
 
388
 
 
389
    If the file is already a backup, it's not copied.
 
390
    """
 
391
    if fn[-1] == '~':
 
392
        return
 
393
    bfn = fn + '~'
 
394
 
 
395
    if has_symlinks() and os.path.islink(fn):
 
396
        target = os.readlink(fn)
 
397
        os.symlink(target, bfn)
 
398
        return
 
399
    inf = file(fn, 'rb')
 
400
    try:
 
401
        content = inf.read()
 
402
    finally:
 
403
        inf.close()
 
404
    
 
405
    outf = file(bfn, 'wb')
 
406
    try:
 
407
        outf.write(content)
 
408
    finally:
 
409
        outf.close()
61
410
 
62
411
 
63
412
def isdir(f):
68
417
        return False
69
418
 
70
419
 
71
 
 
72
420
def isfile(f):
73
421
    """True if f is a regular file."""
74
422
    try:
76
424
    except OSError:
77
425
        return False
78
426
 
 
427
def islink(f):
 
428
    """True if f is a symlink."""
 
429
    try:
 
430
        return S_ISLNK(os.lstat(f)[ST_MODE])
 
431
    except OSError:
 
432
        return False
 
433
 
 
434
def is_inside(dir, fname):
 
435
    """True if fname is inside dir.
 
436
    
 
437
    The parameters should typically be passed to osutils.normpath first, so
 
438
    that . and .. and repeated slashes are eliminated, and the separators
 
439
    are canonical for the platform.
 
440
    
 
441
    The empty string as a dir name is taken as top-of-tree and matches 
 
442
    everything.
 
443
    
 
444
    >>> is_inside('src', pathjoin('src', 'foo.c'))
 
445
    True
 
446
    >>> is_inside('src', 'srccontrol')
 
447
    False
 
448
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
 
449
    True
 
450
    >>> is_inside('foo.c', 'foo.c')
 
451
    True
 
452
    >>> is_inside('foo.c', '')
 
453
    False
 
454
    >>> is_inside('', 'foo.c')
 
455
    True
 
456
    """
 
457
    # XXX: Most callers of this can actually do something smarter by 
 
458
    # looking at the inventory
 
459
    if dir == fname:
 
460
        return True
 
461
    
 
462
    if dir == '':
 
463
        return True
 
464
 
 
465
    if dir[-1] != '/':
 
466
        dir += '/'
 
467
 
 
468
    return fname.startswith(dir)
 
469
 
 
470
 
 
471
def is_inside_any(dir_list, fname):
 
472
    """True if fname is inside any of given dirs."""
 
473
    for dirname in dir_list:
 
474
        if is_inside(dirname, fname):
 
475
            return True
 
476
    else:
 
477
        return False
 
478
 
 
479
 
 
480
def is_inside_or_parent_of_any(dir_list, fname):
 
481
    """True if fname is a child or a parent of any of the given files."""
 
482
    for dirname in dir_list:
 
483
        if is_inside(dirname, fname) or is_inside(fname, dirname):
 
484
            return True
 
485
    else:
 
486
        return False
 
487
 
79
488
 
80
489
def pumpfile(fromfile, tofile):
81
490
    """Copy contents of one file to another."""
82
 
    tofile.write(fromfile.read())
83
 
 
84
 
 
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())
 
491
    BUFSIZE = 32768
 
492
    while True:
 
493
        b = fromfile.read(BUFSIZE)
 
494
        if not b:
 
495
            break
 
496
        tofile.write(b)
 
497
 
 
498
 
 
499
def file_iterator(input_file, readsize=32768):
 
500
    while True:
 
501
        b = input_file.read(readsize)
 
502
        if len(b) == 0:
 
503
            break
 
504
        yield b
91
505
 
92
506
 
93
507
def sha_file(f):
94
 
    import sha
95
508
    if hasattr(f, 'tell'):
96
509
        assert f.tell() == 0
97
510
    s = sha.new()
104
517
    return s.hexdigest()
105
518
 
106
519
 
 
520
 
 
521
def sha_strings(strings):
 
522
    """Return the sha-1 of concatenation of strings"""
 
523
    s = sha.new()
 
524
    map(s.update, strings)
 
525
    return s.hexdigest()
 
526
 
 
527
 
107
528
def sha_string(f):
108
 
    import sha
109
529
    s = sha.new()
110
530
    s.update(f)
111
531
    return s.hexdigest()
112
532
 
113
533
 
114
 
 
115
534
def fingerprint_file(f):
116
 
    import sha
117
535
    s = sha.new()
118
536
    b = f.read()
119
537
    s.update(b)
122
540
            'sha1': s.hexdigest()}
123
541
 
124
542
 
125
 
def config_dir():
126
 
    """Return per-user configuration directory.
127
 
 
128
 
    By default this is ~/.bzr.conf/
129
 
    
130
 
    TODO: Global option --config-dir to override this.
131
 
    """
132
 
    return os.path.expanduser("~/.bzr.conf")
133
 
 
134
 
 
135
 
def _auto_user_id():
136
 
    """Calculate automatic user identification.
137
 
 
138
 
    Returns (realname, email).
139
 
 
140
 
    Only used when none is set in the environment or the id file.
141
 
 
142
 
    This previously used the FQDN as the default domain, but that can
143
 
    be very slow on machines where DNS is broken.  So now we simply
144
 
    use the hostname.
145
 
    """
146
 
    import socket
147
 
 
148
 
    # XXX: Any good way to get real user name on win32?
149
 
 
150
 
    try:
151
 
        import pwd
152
 
        uid = os.getuid()
153
 
        w = pwd.getpwuid(uid)
154
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
155
 
        username = w.pw_name.decode(bzrlib.user_encoding)
156
 
        comma = gecos.find(',')
157
 
        if comma == -1:
158
 
            realname = gecos
159
 
        else:
160
 
            realname = gecos[:comma]
161
 
        if not realname:
162
 
            realname = username
163
 
 
164
 
    except ImportError:
165
 
        import getpass
166
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
167
 
 
168
 
    return realname, (username + '@' + socket.gethostname())
169
 
 
170
 
 
171
 
def _get_user_id():
172
 
    """Return the full user id from a file or environment variable.
173
 
 
174
 
    TODO: Allow taking this from a file in the branch directory too
175
 
    for per-branch ids."""
176
 
    v = os.environ.get('BZREMAIL')
177
 
    if v:
178
 
        return v.decode(bzrlib.user_encoding)
179
 
    
180
 
    try:
181
 
        return (open(os.path.join(config_dir(), "email"))
182
 
                .read()
183
 
                .decode(bzrlib.user_encoding)
184
 
                .rstrip("\r\n"))
185
 
    except IOError, e:
186
 
        if e.errno != errno.ENOENT:
187
 
            raise e
188
 
 
189
 
    v = os.environ.get('EMAIL')
190
 
    if v:
191
 
        return v.decode(bzrlib.user_encoding)
192
 
    else:    
193
 
        return None
194
 
 
195
 
 
196
 
def username():
197
 
    """Return email-style username.
198
 
 
199
 
    Something similar to 'Martin Pool <mbp@sourcefrog.net>'
200
 
 
201
 
    TODO: Check it's reasonably well-formed.
202
 
    """
203
 
    v = _get_user_id()
204
 
    if v:
205
 
        return v
206
 
    
207
 
    name, email = _auto_user_id()
208
 
    if name:
209
 
        return '%s <%s>' % (name, email)
210
 
    else:
211
 
        return email
212
 
 
213
 
 
214
 
_EMAIL_RE = re.compile(r'[\w+.-]+@[\w+.-]+')
215
 
def user_email():
216
 
    """Return just the email component of a username."""
217
 
    e = _get_user_id()
218
 
    if e:
219
 
        m = _EMAIL_RE.search(e)
220
 
        if not m:
221
 
            bailout("%r doesn't seem to contain a reasonable email address" % e)
222
 
        return m.group(0)
223
 
 
224
 
    return _auto_user_id()[1]
225
 
    
226
 
 
227
 
 
228
543
def compare_files(a, b):
229
544
    """Returns true if equal in contents"""
230
545
    BUFSIZE = 4096
237
552
            return True
238
553
 
239
554
 
240
 
 
241
555
def local_time_offset(t=None):
242
556
    """Return offset of local zone from GMT, either at present or at time t."""
243
557
    # python2.3 localtime() can't take None
250
564
        return -time.timezone
251
565
 
252
566
    
253
 
def format_date(t, offset=0, timezone='original'):
 
567
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
568
                show_offset=True):
254
569
    ## TODO: Perhaps a global option to use either universal or local time?
255
570
    ## Or perhaps just let people set $TZ?
256
571
    assert isinstance(t, float)
266
581
        tt = time.localtime(t)
267
582
        offset = local_time_offset(t)
268
583
    else:
269
 
        bailout("unsupported timezone format %r",
270
 
                ['options are "utc", "original", "local"'])
271
 
 
272
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
273
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
584
        raise BzrError("unsupported timezone format %r" % timezone,
 
585
                       ['options are "utc", "original", "local"'])
 
586
    if date_fmt is None:
 
587
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
 
588
    if show_offset:
 
589
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
590
    else:
 
591
        offset_str = ''
 
592
    return (time.strftime(date_fmt, tt) +  offset_str)
274
593
 
275
594
 
276
595
def compact_date(when):
283
602
    return os.fstat(f.fileno())[ST_SIZE]
284
603
 
285
604
 
286
 
if hasattr(os, 'urandom'): # python 2.4 and later
 
605
# Define rand_bytes based on platform.
 
606
try:
 
607
    # Python 2.4 and later have os.urandom,
 
608
    # but it doesn't work on some arches
 
609
    os.urandom(1)
287
610
    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
 
611
except (NotImplementedError, AttributeError):
 
612
    # If python doesn't have os.urandom, or it doesn't work,
 
613
    # then try to first pull random data from /dev/urandom
 
614
    if os.path.exists("/dev/urandom"):
 
615
        rand_bytes = file('/dev/urandom', 'rb').read
 
616
    # Otherwise, use this hack as a last resort
 
617
    else:
 
618
        # not well seeded, but better than nothing
 
619
        def rand_bytes(n):
 
620
            import random
 
621
            s = ''
 
622
            while n:
 
623
                s += chr(random.randint(0, 255))
 
624
                n -= 1
 
625
            return s
 
626
 
 
627
 
 
628
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
 
629
def rand_chars(num):
 
630
    """Return a random string of num alphanumeric characters
 
631
    
 
632
    The result only contains lowercase chars because it may be used on 
 
633
    case-insensitive filesystems.
 
634
    """
 
635
    s = ''
 
636
    for raw_byte in rand_bytes(num):
 
637
        s += ALNUM[ord(raw_byte) % 36]
 
638
    return s
292
639
 
293
640
 
294
641
## TODO: We could later have path objects that remember their list
308
655
    >>> splitpath('a/../b')
309
656
    Traceback (most recent call last):
310
657
    ...
311
 
    BzrError: ("sorry, '..' not allowed in path", [])
 
658
    BzrError: sorry, '..' not allowed in path
312
659
    """
313
660
    assert isinstance(p, types.StringTypes)
314
661
 
319
666
    rps = []
320
667
    for f in ps:
321
668
        if f == '..':
322
 
            bailout("sorry, %r not allowed in path" % f)
 
669
            raise BzrError("sorry, %r not allowed in path" % f)
323
670
        elif (f == '.') or (f == ''):
324
671
            pass
325
672
        else:
330
677
    assert isinstance(p, list)
331
678
    for f in p:
332
679
        if (f == '..') or (f == None) or (f == ''):
333
 
            bailout("sorry, %r not allowed in path" % f)
334
 
    return os.path.join(*p)
335
 
 
336
 
 
 
680
            raise BzrError("sorry, %r not allowed in path" % f)
 
681
    return pathjoin(*p)
 
682
 
 
683
 
 
684
@deprecated_function(zero_nine)
337
685
def appendpath(p1, p2):
338
686
    if p1 == '':
339
687
        return p2
340
688
    else:
341
 
        return os.path.join(p1, p2)
342
 
    
343
 
 
344
 
def extern_command(cmd, ignore_errors = False):
345
 
    mutter('external command: %s' % `cmd`)
346
 
    if os.system(cmd):
347
 
        if not ignore_errors:
348
 
            bailout('command failed')
349
 
 
 
689
        return pathjoin(p1, p2)
 
690
    
 
691
 
 
692
def split_lines(s):
 
693
    """Split s into lines, but without removing the newline characters."""
 
694
    lines = s.split('\n')
 
695
    result = [line + '\n' for line in lines[:-1]]
 
696
    if lines[-1]:
 
697
        result.append(lines[-1])
 
698
    return result
 
699
 
 
700
 
 
701
def hardlinks_good():
 
702
    return sys.platform not in ('win32', 'cygwin', 'darwin')
 
703
 
 
704
 
 
705
def link_or_copy(src, dest):
 
706
    """Hardlink a file, or copy it if it can't be hardlinked."""
 
707
    if not hardlinks_good():
 
708
        copyfile(src, dest)
 
709
        return
 
710
    try:
 
711
        os.link(src, dest)
 
712
    except (OSError, IOError), e:
 
713
        if e.errno != errno.EXDEV:
 
714
            raise
 
715
        copyfile(src, dest)
 
716
 
 
717
def delete_any(full_path):
 
718
    """Delete a file or directory."""
 
719
    try:
 
720
        os.unlink(full_path)
 
721
    except OSError, e:
 
722
    # We may be renaming a dangling inventory id
 
723
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
724
            raise
 
725
        os.rmdir(full_path)
 
726
 
 
727
 
 
728
def has_symlinks():
 
729
    if hasattr(os, 'symlink'):
 
730
        return True
 
731
    else:
 
732
        return False
 
733
        
 
734
 
 
735
def contains_whitespace(s):
 
736
    """True if there are any whitespace characters in s."""
 
737
    for ch in string.whitespace:
 
738
        if ch in s:
 
739
            return True
 
740
    else:
 
741
        return False
 
742
 
 
743
 
 
744
def contains_linebreaks(s):
 
745
    """True if there is any vertical whitespace in s."""
 
746
    for ch in '\f\n\r':
 
747
        if ch in s:
 
748
            return True
 
749
    else:
 
750
        return False
 
751
 
 
752
 
 
753
def relpath(base, path):
 
754
    """Return path relative to base, or raise exception.
 
755
 
 
756
    The path may be either an absolute path or a path relative to the
 
757
    current working directory.
 
758
 
 
759
    os.path.commonprefix (python2.4) has a bad bug that it works just
 
760
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
 
761
    avoids that problem.
 
762
    """
 
763
 
 
764
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
 
765
        ' exceed the platform minimum length (which is %d)' % 
 
766
        MIN_ABS_PATHLENGTH)
 
767
 
 
768
    rp = abspath(path)
 
769
 
 
770
    s = []
 
771
    head = rp
 
772
    while len(head) >= len(base):
 
773
        if head == base:
 
774
            break
 
775
        head, tail = os.path.split(head)
 
776
        if tail:
 
777
            s.insert(0, tail)
 
778
    else:
 
779
        raise PathNotChild(rp, base)
 
780
 
 
781
    if s:
 
782
        return pathjoin(*s)
 
783
    else:
 
784
        return ''
 
785
 
 
786
 
 
787
def safe_unicode(unicode_or_utf8_string):
 
788
    """Coerce unicode_or_utf8_string into unicode.
 
789
 
 
790
    If it is unicode, it is returned.
 
791
    Otherwise it is decoded from utf-8. If a decoding error
 
792
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
 
793
    as a BzrBadParameter exception.
 
794
    """
 
795
    if isinstance(unicode_or_utf8_string, unicode):
 
796
        return unicode_or_utf8_string
 
797
    try:
 
798
        return unicode_or_utf8_string.decode('utf8')
 
799
    except UnicodeDecodeError:
 
800
        raise BzrBadParameterNotUnicode(unicode_or_utf8_string)
 
801
 
 
802
 
 
803
_platform_normalizes_filenames = False
 
804
if sys.platform == 'darwin':
 
805
    _platform_normalizes_filenames = True
 
806
 
 
807
 
 
808
def normalizes_filenames():
 
809
    """Return True if this platform normalizes unicode filenames.
 
810
 
 
811
    Mac OSX does, Windows/Linux do not.
 
812
    """
 
813
    return _platform_normalizes_filenames
 
814
 
 
815
 
 
816
def _accessible_normalized_filename(path):
 
817
    """Get the unicode normalized path, and if you can access the file.
 
818
 
 
819
    On platforms where the system normalizes filenames (Mac OSX),
 
820
    you can access a file by any path which will normalize correctly.
 
821
    On platforms where the system does not normalize filenames 
 
822
    (Windows, Linux), you have to access a file by its exact path.
 
823
 
 
824
    Internally, bzr only supports NFC/NFKC normalization, since that is 
 
825
    the standard for XML documents.
 
826
 
 
827
    So return the normalized path, and a flag indicating if the file
 
828
    can be accessed by that path.
 
829
    """
 
830
 
 
831
    return unicodedata.normalize('NFKC', unicode(path)), True
 
832
 
 
833
 
 
834
def _inaccessible_normalized_filename(path):
 
835
    __doc__ = _accessible_normalized_filename.__doc__
 
836
 
 
837
    normalized = unicodedata.normalize('NFKC', unicode(path))
 
838
    return normalized, normalized == path
 
839
 
 
840
 
 
841
if _platform_normalizes_filenames:
 
842
    normalized_filename = _accessible_normalized_filename
 
843
else:
 
844
    normalized_filename = _inaccessible_normalized_filename
 
845
 
 
846
 
 
847
def terminal_width():
 
848
    """Return estimated terminal width."""
 
849
    if sys.platform == 'win32':
 
850
        import bzrlib.win32console
 
851
        return bzrlib.win32console.get_console_size()[0]
 
852
    width = 0
 
853
    try:
 
854
        import struct, fcntl, termios
 
855
        s = struct.pack('HHHH', 0, 0, 0, 0)
 
856
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
 
857
        width = struct.unpack('HHHH', x)[1]
 
858
    except IOError:
 
859
        pass
 
860
    if width <= 0:
 
861
        try:
 
862
            width = int(os.environ['COLUMNS'])
 
863
        except:
 
864
            pass
 
865
    if width <= 0:
 
866
        width = 80
 
867
 
 
868
    return width
 
869
 
 
870
def supports_executable():
 
871
    return sys.platform != "win32"
 
872
 
 
873
 
 
874
_validWin32PathRE = re.compile(r'^([A-Za-z]:[/\\])?[^:<>*"?\|]*$')
 
875
 
 
876
 
 
877
def check_legal_path(path):
 
878
    """Check whether the supplied path is legal.  
 
879
    This is only required on Windows, so we don't test on other platforms
 
880
    right now.
 
881
    """
 
882
    if sys.platform != "win32":
 
883
        return
 
884
    if _validWin32PathRE.match(path) is None:
 
885
        raise IllegalPath(path)
 
886
 
 
887
 
 
888
def walkdirs(top, prefix=""):
 
889
    """Yield data about all the directories in a tree.
 
890
    
 
891
    This yields all the data about the contents of a directory at a time.
 
892
    After each directory has been yielded, if the caller has mutated the list
 
893
    to exclude some directories, they are then not descended into.
 
894
    
 
895
    The data yielded is of the form:
 
896
    ((directory-relpath, directory-path-from-top),
 
897
    [(relpath, basename, kind, lstat), ...]),
 
898
     - directory-relpath is the relative path of the directory being returned
 
899
       with respect to top. prefix is prepended to this.
 
900
     - directory-path-from-root is the path including top for this directory. 
 
901
       It is suitable for use with os functions.
 
902
     - relpath is the relative path within the subtree being walked.
 
903
     - basename is the basename of the path
 
904
     - kind is the kind of the file now. If unknown then the file is not
 
905
       present within the tree - but it may be recorded as versioned. See
 
906
       versioned_kind.
 
907
     - lstat is the stat data *if* the file was statted.
 
908
     - planned, not implemented: 
 
909
       path_from_tree_root is the path from the root of the tree.
 
910
 
 
911
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
 
912
        allows one to walk a subtree but get paths that are relative to a tree
 
913
        rooted higher up.
 
914
    :return: an iterator over the dirs.
 
915
    """
 
916
    #TODO there is a bit of a smell where the results of the directory-
 
917
    # summary in this, and the path from the root, may not agree 
 
918
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
 
919
    # potentially confusing output. We should make this more robust - but
 
920
    # not at a speed cost. RBC 20060731
 
921
    lstat = os.lstat
 
922
    pending = []
 
923
    _directory = _directory_kind
 
924
    _listdir = listdir
 
925
    pending = [(prefix, "", _directory, None, top)]
 
926
    while pending:
 
927
        dirblock = []
 
928
        currentdir = pending.pop()
 
929
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
 
930
        top = currentdir[4]
 
931
        if currentdir[0]:
 
932
            relroot = currentdir[0] + '/'
 
933
        else:
 
934
            relroot = ""
 
935
        for name in sorted(_listdir(top)):
 
936
            abspath = top + '/' + name
 
937
            statvalue = lstat(abspath)
 
938
            dirblock.append((relroot + name, name,
 
939
                file_kind_from_stat_mode(statvalue.st_mode),
 
940
                statvalue, abspath))
 
941
        yield (currentdir[0], top), dirblock
 
942
        # push the user specified dirs from dirblock
 
943
        for dir in reversed(dirblock):
 
944
            if dir[2] == _directory:
 
945
                pending.append(dir)
 
946
 
 
947
 
 
948
def copy_tree(from_path, to_path, handlers={}):
 
949
    """Copy all of the entries in from_path into to_path.
 
950
 
 
951
    :param from_path: The base directory to copy. 
 
952
    :param to_path: The target directory. If it does not exist, it will
 
953
        be created.
 
954
    :param handlers: A dictionary of functions, which takes a source and
 
955
        destinations for files, directories, etc.
 
956
        It is keyed on the file kind, such as 'directory', 'symlink', or 'file'
 
957
        'file', 'directory', and 'symlink' should always exist.
 
958
        If they are missing, they will be replaced with 'os.mkdir()',
 
959
        'os.readlink() + os.symlink()', and 'shutil.copy2()', respectively.
 
960
    """
 
961
    # Now, just copy the existing cached tree to the new location
 
962
    # We use a cheap trick here.
 
963
    # Absolute paths are prefixed with the first parameter
 
964
    # relative paths are prefixed with the second.
 
965
    # So we can get both the source and target returned
 
966
    # without any extra work.
 
967
 
 
968
    def copy_dir(source, dest):
 
969
        os.mkdir(dest)
 
970
 
 
971
    def copy_link(source, dest):
 
972
        """Copy the contents of a symlink"""
 
973
        link_to = os.readlink(source)
 
974
        os.symlink(link_to, dest)
 
975
 
 
976
    real_handlers = {'file':shutil.copy2,
 
977
                     'symlink':copy_link,
 
978
                     'directory':copy_dir,
 
979
                    }
 
980
    real_handlers.update(handlers)
 
981
 
 
982
    if not os.path.exists(to_path):
 
983
        real_handlers['directory'](from_path, to_path)
 
984
 
 
985
    for dir_info, entries in walkdirs(from_path, prefix=to_path):
 
986
        for relpath, name, kind, st, abspath in entries:
 
987
            real_handlers[kind](abspath, relpath)
 
988
 
 
989
 
 
990
def path_prefix_key(path):
 
991
    """Generate a prefix-order path key for path.
 
992
 
 
993
    This can be used to sort paths in the same way that walkdirs does.
 
994
    """
 
995
    return (dirname(path) , path)
 
996
 
 
997
 
 
998
def compare_paths_prefix_order(path_a, path_b):
 
999
    """Compare path_a and path_b to generate the same order walkdirs uses."""
 
1000
    key_a = path_prefix_key(path_a)
 
1001
    key_b = path_prefix_key(path_b)
 
1002
    return cmp(key_a, key_b)