~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: John Arbash Meinel
  • Date: 2006-08-23 23:01:01 UTC
  • mto: This revision was merged to the branch mainline in revision 1979.
  • Revision ID: john@arbash-meinel.com-20060823230101-94b533ae885a196a
Get rid of direct imports of exceptions

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, sys
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 bzrlib.errors import BzrError
 
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)
23
53
from bzrlib.trace import mutter
24
 
import bzrlib
 
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)
48
85
    # TODO: I'm not really sure this is the best format either.x
49
86
    global _QUOTE_RE
50
87
    if _QUOTE_RE == None:
51
 
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/_~-])')
 
88
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
52
89
        
53
90
    if _QUOTE_RE.search(f):
54
91
        return '"' + f + '"'
56
93
        return f
57
94
 
58
95
 
59
 
def file_kind(f):
60
 
    mode = os.lstat(f)[ST_MODE]
61
 
    if S_ISREG(mode):
62
 
        return 'file'
63
 
    elif S_ISDIR(mode):
64
 
        return 'directory'
65
 
    elif S_ISLNK(mode):
66
 
        return 'symlink'
67
 
    else:
68
 
        raise BzrError("can't handle file kind with mode %o of %r" % (mode, f))
 
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
69
137
 
70
138
 
71
139
def kind_marker(kind):
72
140
    if kind == 'file':
73
141
        return ''
74
 
    elif kind == 'directory':
 
142
    elif kind == _directory_kind:
75
143
        return '/'
76
144
    elif kind == 'symlink':
77
145
        return '@'
78
146
    else:
79
147
        raise BzrError('invalid file kind %r' % kind)
80
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)
81
382
 
82
383
 
83
384
def backup_file(fn):
87
388
 
88
389
    If the file is already a backup, it's not copied.
89
390
    """
90
 
    import os
91
391
    if fn[-1] == '~':
92
392
        return
93
393
    bfn = fn + '~'
94
394
 
 
395
    if has_symlinks() and os.path.islink(fn):
 
396
        target = os.readlink(fn)
 
397
        os.symlink(target, bfn)
 
398
        return
95
399
    inf = file(fn, 'rb')
96
400
    try:
97
401
        content = inf.read()
104
408
    finally:
105
409
        outf.close()
106
410
 
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
 
 
119
 
 
120
411
 
121
412
def isdir(f):
122
413
    """True if f is an accessible directory."""
126
417
        return False
127
418
 
128
419
 
129
 
 
130
420
def isfile(f):
131
421
    """True if f is a regular file."""
132
422
    try:
134
424
    except OSError:
135
425
        return False
136
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
137
433
 
138
434
def is_inside(dir, fname):
139
435
    """True if fname is inside dir.
140
436
    
141
 
    The parameters should typically be passed to os.path.normpath first, so
 
437
    The parameters should typically be passed to osutils.normpath first, so
142
438
    that . and .. and repeated slashes are eliminated, and the separators
143
439
    are canonical for the platform.
144
440
    
145
441
    The empty string as a dir name is taken as top-of-tree and matches 
146
442
    everything.
147
443
    
148
 
    >>> is_inside('src', 'src/foo.c')
 
444
    >>> is_inside('src', pathjoin('src', 'foo.c'))
149
445
    True
150
446
    >>> is_inside('src', 'srccontrol')
151
447
    False
152
 
    >>> is_inside('src', 'src/a/a/a/foo.c')
 
448
    >>> is_inside('src', pathjoin('src', 'a', 'a', 'a', 'foo.c'))
153
449
    True
154
450
    >>> is_inside('foo.c', 'foo.c')
155
451
    True
165
461
    
166
462
    if dir == '':
167
463
        return True
168
 
    
169
 
    if dir[-1] != os.sep:
170
 
        dir += os.sep
171
 
    
 
464
 
 
465
    if dir[-1] != '/':
 
466
        dir += '/'
 
467
 
172
468
    return fname.startswith(dir)
173
469
 
174
470
 
181
477
        return False
182
478
 
183
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
 
 
488
 
184
489
def pumpfile(fromfile, tofile):
185
490
    """Copy contents of one file to another."""
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())
 
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
195
505
 
196
506
 
197
507
def sha_file(f):
198
 
    import sha
199
508
    if hasattr(f, 'tell'):
200
509
        assert f.tell() == 0
201
510
    s = sha.new()
208
517
    return s.hexdigest()
209
518
 
210
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
 
211
528
def sha_string(f):
212
 
    import sha
213
529
    s = sha.new()
214
530
    s.update(f)
215
531
    return s.hexdigest()
216
532
 
217
533
 
218
 
 
219
534
def fingerprint_file(f):
220
 
    import sha
221
535
    s = sha.new()
222
536
    b = f.read()
223
537
    s.update(b)
226
540
            'sha1': s.hexdigest()}
227
541
 
228
542
 
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
 
 
353
543
def compare_files(a, b):
354
544
    """Returns true if equal in contents"""
355
545
    BUFSIZE = 4096
362
552
            return True
363
553
 
364
554
 
365
 
 
366
555
def local_time_offset(t=None):
367
556
    """Return offset of local zone from GMT, either at present or at time t."""
368
557
    # python2.3 localtime() can't take None
375
564
        return -time.timezone
376
565
 
377
566
    
378
 
def format_date(t, offset=0, timezone='original'):
 
567
def format_date(t, offset=0, timezone='original', date_fmt=None, 
 
568
                show_offset=True):
379
569
    ## TODO: Perhaps a global option to use either universal or local time?
380
570
    ## Or perhaps just let people set $TZ?
381
571
    assert isinstance(t, float)
393
583
    else:
394
584
        raise BzrError("unsupported timezone format %r" % timezone,
395
585
                       ['options are "utc", "original", "local"'])
396
 
 
397
 
    return (time.strftime("%a %Y-%m-%d %H:%M:%S", tt)
398
 
            + ' %+03d%02d' % (offset / 3600, (offset / 60) % 60))
 
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)
399
593
 
400
594
 
401
595
def compact_date(when):
408
602
    return os.fstat(f.fileno())[ST_SIZE]
409
603
 
410
604
 
411
 
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)
412
610
    rand_bytes = os.urandom
413
 
elif sys.platform == 'linux2':
414
 
    rand_bytes = file('/dev/urandom', 'rb').read
415
 
else:
416
 
    # not well seeded, but better than nothing
417
 
    def rand_bytes(n):
418
 
        import random
419
 
        s = ''
420
 
        while n:
421
 
            s += chr(random.randint(0, 255))
422
 
            n -= 1
423
 
        return s
 
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
424
639
 
425
640
 
426
641
## TODO: We could later have path objects that remember their list
463
678
    for f in p:
464
679
        if (f == '..') or (f == None) or (f == ''):
465
680
            raise BzrError("sorry, %r not allowed in path" % f)
466
 
    return os.path.join(*p)
467
 
 
468
 
 
 
681
    return pathjoin(*p)
 
682
 
 
683
 
 
684
@deprecated_function(zero_nine)
469
685
def appendpath(p1, p2):
470
686
    if p1 == '':
471
687
        return p2
472
688
    else:
473
 
        return os.path.join(p1, p2)
474
 
    
475
 
 
476
 
def extern_command(cmd, ignore_errors = False):
477
 
    mutter('external command: %s' % `cmd`)
478
 
    if os.system(cmd):
479
 
        if not ignore_errors:
480
 
            raise BzrError('command failed')
481
 
 
482
 
 
483
 
def _read_config_value(name):
484
 
    """Read a config value from the file ~/.bzr.conf/<name>
485
 
    Return None if the file does not exist"""
486
 
    try:
487
 
        f = file(os.path.join(config_dir(), name), "r")
488
 
        return f.read().decode(bzrlib.user_encoding).rstrip("\r\n")
489
 
    except IOError, e:
490
 
        if e.errno == errno.ENOENT:
491
 
            return None
492
 
        raise
493
 
 
494
 
 
 
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)