~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:54:05 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506235405-wii4elupfhzl3jvy
Add __str__ to the new helper classes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from cStringIO import StringIO
18
17
import os
19
18
import re
20
19
import stat
21
 
from stat import (S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE,
22
 
                  S_ISCHR, S_ISBLK, S_ISFIFO, S_ISSOCK)
 
20
from stat import S_ISREG, S_ISDIR, S_ISLNK, ST_MODE, ST_SIZE
23
21
import sys
24
22
import time
 
23
import codecs
25
24
 
26
25
from bzrlib.lazy_import import lazy_import
27
26
lazy_import(globals(), """
28
 
import codecs
29
27
from datetime import datetime
30
28
import errno
31
29
from ntpath import (abspath as _nt_abspath,
35
33
                    splitdrive as _nt_splitdrive,
36
34
                    )
37
35
import posixpath
38
 
import sha
39
36
import shutil
40
37
from shutil import (
41
38
    rmtree,
42
39
    )
 
40
import socket
 
41
import subprocess
43
42
import tempfile
44
43
from tempfile import (
45
44
    mkdtemp,
49
48
from bzrlib import (
50
49
    cache_utf8,
51
50
    errors,
 
51
    trace,
52
52
    win32utils,
53
53
    )
54
54
""")
55
55
 
 
56
from bzrlib.symbol_versioning import (
 
57
    deprecated_function,
 
58
    deprecated_in,
 
59
    )
 
60
 
 
61
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
 
62
# of 2.5
 
63
if sys.version_info < (2, 5):
 
64
    import md5 as _mod_md5
 
65
    md5 = _mod_md5.new
 
66
    import sha as _mod_sha
 
67
    sha = _mod_sha.new
 
68
else:
 
69
    from hashlib import (
 
70
        md5,
 
71
        sha1 as sha,
 
72
        )
 
73
 
 
74
 
56
75
import bzrlib
57
76
from bzrlib import symbol_versioning
58
 
from bzrlib.symbol_versioning import (
59
 
    deprecated_function,
60
 
    zero_nine,
61
 
    )
62
 
from bzrlib.trace import mutter
63
 
 
 
77
 
 
78
 
 
79
# Cross platform wall-clock time functionality with decent resolution.
 
80
# On Linux ``time.clock`` returns only CPU time. On Windows, ``time.time()``
 
81
# only has a resolution of ~15ms. Note that ``time.clock()`` is not
 
82
# synchronized with ``time.time()``, this is only meant to be used to find
 
83
# delta times by subtracting from another call to this function.
 
84
timer_func = time.time
 
85
if sys.platform == 'win32':
 
86
    timer_func = time.clock
64
87
 
65
88
# On win32, O_BINARY is used to indicate the file should
66
89
# be opened in binary mode, rather than text mode.
67
90
# On other platforms, O_BINARY doesn't exist, because
68
91
# they always open in binary mode, so it is okay to
69
 
# OR with 0 on those platforms
 
92
# OR with 0 on those platforms.
 
93
# O_NOINHERIT and O_TEXT exists only on win32 too.
70
94
O_BINARY = getattr(os, 'O_BINARY', 0)
71
 
 
72
 
# On posix, use lstat instead of stat so that we can
73
 
# operate on broken symlinks. On Windows revert to stat.
74
 
lstat = getattr(os, 'lstat', os.stat)
 
95
O_TEXT = getattr(os, 'O_TEXT', 0)
 
96
O_NOINHERIT = getattr(os, 'O_NOINHERIT', 0)
 
97
 
 
98
 
 
99
def get_unicode_argv():
 
100
    try:
 
101
        user_encoding = get_user_encoding()
 
102
        return [a.decode(user_encoding) for a in sys.argv[1:]]
 
103
    except UnicodeDecodeError:
 
104
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
105
                                                            "encoding." % a))
 
106
 
75
107
 
76
108
def make_readonly(filename):
77
109
    """Make a filename read-only."""
78
 
    mod = lstat(filename).st_mode
 
110
    mod = os.lstat(filename).st_mode
79
111
    if not stat.S_ISLNK(mod):
80
112
        mod = mod & 0777555
81
113
        os.chmod(filename, mod)
82
114
 
83
115
 
84
116
def make_writable(filename):
85
 
    mod = lstat(filename).st_mode
 
117
    mod = os.lstat(filename).st_mode
86
118
    if not stat.S_ISLNK(mod):
87
119
        mod = mod | 0200
88
120
        os.chmod(filename, mod)
89
121
 
90
122
 
 
123
def minimum_path_selection(paths):
 
124
    """Return the smallset subset of paths which are outside paths.
 
125
 
 
126
    :param paths: A container (and hence not None) of paths.
 
127
    :return: A set of paths sufficient to include everything in paths via
 
128
        is_inside, drawn from the paths parameter.
 
129
    """
 
130
    if len(paths) < 2:
 
131
        return set(paths)
 
132
 
 
133
    def sort_key(path):
 
134
        return path.split('/')
 
135
    sorted_paths = sorted(list(paths), key=sort_key)
 
136
 
 
137
    search_paths = [sorted_paths[0]]
 
138
    for path in sorted_paths[1:]:
 
139
        if not is_inside(search_paths[-1], path):
 
140
            # This path is unique, add it
 
141
            search_paths.append(path)
 
142
 
 
143
    return set(search_paths)
 
144
 
 
145
 
91
146
_QUOTE_RE = None
92
147
 
93
148
 
100
155
    global _QUOTE_RE
101
156
    if _QUOTE_RE is None:
102
157
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
103
 
        
 
158
 
104
159
    if _QUOTE_RE.search(f):
105
160
        return '"' + f + '"'
106
161
    else:
109
164
 
110
165
_directory_kind = 'directory'
111
166
 
112
 
_formats = {
113
 
    stat.S_IFDIR:_directory_kind,
114
 
    stat.S_IFCHR:'chardev',
115
 
    stat.S_IFBLK:'block',
116
 
    stat.S_IFREG:'file',
117
 
    stat.S_IFIFO:'fifo',
118
 
    stat.S_IFLNK:'symlink',
119
 
    stat.S_IFSOCK:'socket',
120
 
}
121
 
 
122
 
 
123
 
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
124
 
    """Generate a file kind from a stat mode. This is used in walkdirs.
125
 
 
126
 
    Its performance is critical: Do not mutate without careful benchmarking.
127
 
    """
128
 
    try:
129
 
        return _formats[stat_mode & 0170000]
130
 
    except KeyError:
131
 
        return _unknown
132
 
 
133
 
 
134
 
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
135
 
    try:
136
 
        return _mapper(_lstat(f).st_mode)
137
 
    except OSError, e:
138
 
        if getattr(e, 'errno', None) == errno.ENOENT:
139
 
            raise errors.NoSuchFile(f)
140
 
        raise
141
 
 
142
 
 
143
167
def get_umask():
144
168
    """Return the current umask"""
145
169
    # Assume that people aren't messing with the umask while running
162
186
    try:
163
187
        return _kind_marker_map[kind]
164
188
    except KeyError:
165
 
        raise errors.BzrError('invalid file kind %r' % kind)
 
189
        # Slightly faster than using .get(, '') when the common case is that
 
190
        # kind will be found
 
191
        return ''
166
192
 
167
193
 
168
194
lexists = getattr(os.path, 'lexists', None)
181
207
 
182
208
def fancy_rename(old, new, rename_func, unlink_func):
183
209
    """A fancy rename, when you don't have atomic rename.
184
 
    
 
210
 
185
211
    :param old: The old path, to rename from
186
212
    :param new: The new path, to rename to
187
213
    :param rename_func: The potentially non-atomic rename function
188
 
    :param unlink_func: A way to delete the target file if the full rename succeeds
 
214
    :param unlink_func: A way to delete the target file if the full rename
 
215
        succeeds
189
216
    """
190
 
 
191
217
    # sftp rename doesn't allow overwriting, so play tricks:
192
 
    import random
193
218
    base = os.path.basename(new)
194
219
    dirname = os.path.dirname(new)
195
 
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
 
220
    # callers use different encodings for the paths so the following MUST
 
221
    # respect that. We rely on python upcasting to unicode if new is unicode
 
222
    # and keeping a str if not.
 
223
    tmp_name = 'tmp.%s.%.9f.%d.%s' % (base, time.time(),
 
224
                                      os.getpid(), rand_chars(10))
196
225
    tmp_name = pathjoin(dirname, tmp_name)
197
226
 
198
227
    # Rename the file out of the way, but keep track if it didn't exist
218
247
    else:
219
248
        file_existed = True
220
249
 
 
250
    failure_exc = None
221
251
    success = False
222
252
    try:
223
 
        # This may throw an exception, in which case success will
224
 
        # not be set.
225
 
        rename_func(old, new)
226
 
        success = True
 
253
        try:
 
254
            # This may throw an exception, in which case success will
 
255
            # not be set.
 
256
            rename_func(old, new)
 
257
            success = True
 
258
        except (IOError, OSError), e:
 
259
            # source and target may be aliases of each other (e.g. on a
 
260
            # case-insensitive filesystem), so we may have accidentally renamed
 
261
            # source by when we tried to rename target
 
262
            failure_exc = sys.exc_info()
 
263
            if (file_existed and e.errno in (None, errno.ENOENT)
 
264
                and old.lower() == new.lower()):
 
265
                # source and target are the same file on a case-insensitive
 
266
                # filesystem, so we don't generate an exception
 
267
                failure_exc = None
227
268
    finally:
228
269
        if file_existed:
229
270
            # If the file used to exist, rename it back into place
232
273
                unlink_func(tmp_name)
233
274
            else:
234
275
                rename_func(tmp_name, new)
 
276
    if failure_exc is not None:
 
277
        raise failure_exc[0], failure_exc[1], failure_exc[2]
235
278
 
236
279
 
237
280
# In Python 2.4.2 and older, os.path.abspath and os.path.realpath
295
338
        path = cwd + '\\' + path
296
339
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
297
340
 
298
 
if win32utils.winver == 'Windows 98':
299
 
    _win32_abspath = _win98_abspath
300
 
 
301
341
 
302
342
def _win32_realpath(path):
303
343
    # Real _nt_realpath doesn't have a problem with a unicode cwd
320
360
    return _win32_fixdrive(tempfile.mkdtemp(*args, **kwargs).replace('\\', '/'))
321
361
 
322
362
 
 
363
def _add_rename_error_details(e, old, new):
 
364
    new_e = OSError(e.errno, "failed to rename %s to %s: %s"
 
365
        % (old, new, e.strerror))
 
366
    new_e.filename = old
 
367
    new_e.to_filename = new
 
368
    return new_e
 
369
 
 
370
 
323
371
def _win32_rename(old, new):
324
372
    """We expect to be able to atomically replace 'new' with old.
325
373
 
326
374
    On win32, if new exists, it must be moved out of the way first,
327
 
    and then deleted. 
 
375
    and then deleted.
328
376
    """
329
377
    try:
330
 
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
 
378
        fancy_rename(old, new, rename_func=_wrapped_rename, unlink_func=os.unlink)
331
379
    except OSError, e:
332
380
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
333
 
            # If we try to rename a non-existant file onto cwd, we get 
334
 
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
 
381
            # If we try to rename a non-existant file onto cwd, we get
 
382
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
335
383
            # if the old path doesn't exist, sometimes we get EACCES
336
384
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
337
385
            os.lstat(old)
338
386
        raise
339
387
 
340
388
 
 
389
def _wrapped_rename(old, new):
 
390
    """Rename a file or directory"""
 
391
    try:
 
392
        os.rename(old, new)
 
393
    except (IOError, OSError), e:
 
394
        # this is eventually called by all rename-like functions, so should 
 
395
        # catch all of them
 
396
        raise _add_rename_error_details(e, old, new)
 
397
 
 
398
 
341
399
def _mac_getcwd():
342
 
    return unicodedata.normalize('NFKC', os.getcwdu())
 
400
    return unicodedata.normalize('NFC', os.getcwdu())
343
401
 
344
402
 
345
403
# Default is to just use the python builtins, but these can be rebound on
348
406
realpath = _posix_realpath
349
407
pathjoin = os.path.join
350
408
normpath = os.path.normpath
 
409
rename = _wrapped_rename # overridden below on win32
351
410
getcwd = os.getcwdu
352
 
rename = os.rename
353
411
dirname = os.path.dirname
354
412
basename = os.path.basename
355
413
split = os.path.split
362
420
 
363
421
 
364
422
if sys.platform == 'win32':
365
 
    abspath = _win32_abspath
 
423
    if win32utils.winver == 'Windows 98':
 
424
        abspath = _win98_abspath
 
425
    else:
 
426
        abspath = _win32_abspath
366
427
    realpath = _win32_realpath
367
428
    pathjoin = _win32_pathjoin
368
429
    normpath = _win32_normpath
388
449
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
389
450
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
390
451
        return shutil.rmtree(path, ignore_errors, onerror)
 
452
 
 
453
    f = win32utils.get_unicode_argv     # special function or None
 
454
    if f is not None:
 
455
        get_unicode_argv = f
 
456
 
391
457
elif sys.platform == 'darwin':
392
458
    getcwd = _mac_getcwd
393
459
 
397
463
 
398
464
    This attempts to check both sys.stdout and sys.stdin to see
399
465
    what encoding they are in, and if that fails it falls back to
400
 
    bzrlib.user_encoding.
 
466
    osutils.get_user_encoding().
401
467
    The problem is that on Windows, locale.getpreferredencoding()
402
468
    is not the same encoding as that used by the console:
403
469
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
405
471
    On my standard US Windows XP, the preferred encoding is
406
472
    cp1252, but the console is cp437
407
473
    """
 
474
    from bzrlib.trace import mutter
408
475
    output_encoding = getattr(sys.stdout, 'encoding', None)
409
476
    if not output_encoding:
410
477
        input_encoding = getattr(sys.stdin, 'encoding', None)
411
478
        if not input_encoding:
412
 
            output_encoding = bzrlib.user_encoding
413
 
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
479
            output_encoding = get_user_encoding()
 
480
            mutter('encoding stdout as osutils.get_user_encoding() %r',
 
481
                   output_encoding)
414
482
        else:
415
483
            output_encoding = input_encoding
416
484
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
418
486
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
419
487
    if output_encoding == 'cp0':
420
488
        # invalid encoding (cp0 means 'no codepage' on Windows)
421
 
        output_encoding = bzrlib.user_encoding
 
489
        output_encoding = get_user_encoding()
422
490
        mutter('cp0 is invalid encoding.'
423
 
               ' encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
491
               ' encoding stdout as osutils.get_user_encoding() %r',
 
492
               output_encoding)
424
493
    # check encoding
425
494
    try:
426
495
        codecs.lookup(output_encoding)
428
497
        sys.stderr.write('bzr: warning:'
429
498
                         ' unknown terminal encoding %s.\n'
430
499
                         '  Using encoding %s instead.\n'
431
 
                         % (output_encoding, bzrlib.user_encoding)
 
500
                         % (output_encoding, get_user_encoding())
432
501
                        )
433
 
        output_encoding = bzrlib.user_encoding
 
502
        output_encoding = get_user_encoding()
434
503
 
435
504
    return output_encoding
436
505
 
447
516
        return pathjoin(F(p), e)
448
517
 
449
518
 
450
 
def backup_file(fn):
451
 
    """Copy a file to a backup.
452
 
 
453
 
    Backups are named in GNU-style, with a ~ suffix.
454
 
 
455
 
    If the file is already a backup, it's not copied.
456
 
    """
457
 
    if fn[-1] == '~':
458
 
        return
459
 
    bfn = fn + '~'
460
 
 
461
 
    if has_symlinks() and os.path.islink(fn):
462
 
        target = os.readlink(fn)
463
 
        os.symlink(target, bfn)
464
 
        return
465
 
    inf = file(fn, 'rb')
466
 
    try:
467
 
        content = inf.read()
468
 
    finally:
469
 
        inf.close()
470
 
    
471
 
    outf = file(bfn, 'wb')
472
 
    try:
473
 
        outf.write(content)
474
 
    finally:
475
 
        outf.close()
476
 
 
477
 
 
478
519
def isdir(f):
479
520
    """True if f is an accessible directory."""
480
521
    try:
499
540
 
500
541
def is_inside(dir, fname):
501
542
    """True if fname is inside dir.
502
 
    
 
543
 
503
544
    The parameters should typically be passed to osutils.normpath first, so
504
545
    that . and .. and repeated slashes are eliminated, and the separators
505
546
    are canonical for the platform.
506
 
    
507
 
    The empty string as a dir name is taken as top-of-tree and matches 
 
547
 
 
548
    The empty string as a dir name is taken as top-of-tree and matches
508
549
    everything.
509
550
    """
510
 
    # XXX: Most callers of this can actually do something smarter by 
 
551
    # XXX: Most callers of this can actually do something smarter by
511
552
    # looking at the inventory
512
553
    if dir == fname:
513
554
        return True
514
 
    
 
555
 
515
556
    if dir == '':
516
557
        return True
517
558
 
537
578
    return False
538
579
 
539
580
 
540
 
def pumpfile(fromfile, tofile):
541
 
    """Copy contents of one file to another."""
542
 
    BUFSIZE = 32768
543
 
    while True:
544
 
        b = fromfile.read(BUFSIZE)
545
 
        if not b:
546
 
            break
547
 
        tofile.write(b)
 
581
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768,
 
582
             report_activity=None, direction='read'):
 
583
    """Copy contents of one file to another.
 
584
 
 
585
    The read_length can either be -1 to read to end-of-file (EOF) or
 
586
    it can specify the maximum number of bytes to read.
 
587
 
 
588
    The buff_size represents the maximum size for each read operation
 
589
    performed on from_file.
 
590
 
 
591
    :param report_activity: Call this as bytes are read, see
 
592
        Transport._report_activity
 
593
    :param direction: Will be passed to report_activity
 
594
 
 
595
    :return: The number of bytes copied.
 
596
    """
 
597
    length = 0
 
598
    if read_length >= 0:
 
599
        # read specified number of bytes
 
600
 
 
601
        while read_length > 0:
 
602
            num_bytes_to_read = min(read_length, buff_size)
 
603
 
 
604
            block = from_file.read(num_bytes_to_read)
 
605
            if not block:
 
606
                # EOF reached
 
607
                break
 
608
            if report_activity is not None:
 
609
                report_activity(len(block), direction)
 
610
            to_file.write(block)
 
611
 
 
612
            actual_bytes_read = len(block)
 
613
            read_length -= actual_bytes_read
 
614
            length += actual_bytes_read
 
615
    else:
 
616
        # read to EOF
 
617
        while True:
 
618
            block = from_file.read(buff_size)
 
619
            if not block:
 
620
                # EOF reached
 
621
                break
 
622
            if report_activity is not None:
 
623
                report_activity(len(block), direction)
 
624
            to_file.write(block)
 
625
            length += len(block)
 
626
    return length
 
627
 
 
628
 
 
629
def pump_string_file(bytes, file_handle, segment_size=None):
 
630
    """Write bytes to file_handle in many smaller writes.
 
631
 
 
632
    :param bytes: The string to write.
 
633
    :param file_handle: The file to write to.
 
634
    """
 
635
    # Write data in chunks rather than all at once, because very large
 
636
    # writes fail on some platforms (e.g. Windows with SMB  mounted
 
637
    # drives).
 
638
    if not segment_size:
 
639
        segment_size = 5242880 # 5MB
 
640
    segments = range(len(bytes) / segment_size + 1)
 
641
    write = file_handle.write
 
642
    for segment_index in segments:
 
643
        segment = buffer(bytes, segment_index * segment_size, segment_size)
 
644
        write(segment)
548
645
 
549
646
 
550
647
def file_iterator(input_file, readsize=32768):
556
653
 
557
654
 
558
655
def sha_file(f):
559
 
    if getattr(f, 'tell', None) is not None:
560
 
        assert f.tell() == 0
561
 
    s = sha.new()
 
656
    """Calculate the hexdigest of an open file.
 
657
 
 
658
    The file cursor should be already at the start.
 
659
    """
 
660
    s = sha()
562
661
    BUFSIZE = 128<<10
563
662
    while True:
564
663
        b = f.read(BUFSIZE)
568
667
    return s.hexdigest()
569
668
 
570
669
 
571
 
 
572
 
def sha_strings(strings):
 
670
def size_sha_file(f):
 
671
    """Calculate the size and hexdigest of an open file.
 
672
 
 
673
    The file cursor should be already at the start and
 
674
    the caller is responsible for closing the file afterwards.
 
675
    """
 
676
    size = 0
 
677
    s = sha()
 
678
    BUFSIZE = 128<<10
 
679
    while True:
 
680
        b = f.read(BUFSIZE)
 
681
        if not b:
 
682
            break
 
683
        size += len(b)
 
684
        s.update(b)
 
685
    return size, s.hexdigest()
 
686
 
 
687
 
 
688
def sha_file_by_name(fname):
 
689
    """Calculate the SHA1 of a file by reading the full text"""
 
690
    s = sha()
 
691
    f = os.open(fname, os.O_RDONLY | O_BINARY | O_NOINHERIT)
 
692
    try:
 
693
        while True:
 
694
            b = os.read(f, 1<<16)
 
695
            if not b:
 
696
                return s.hexdigest()
 
697
            s.update(b)
 
698
    finally:
 
699
        os.close(f)
 
700
 
 
701
 
 
702
def sha_strings(strings, _factory=sha):
573
703
    """Return the sha-1 of concatenation of strings"""
574
 
    s = sha.new()
 
704
    s = _factory()
575
705
    map(s.update, strings)
576
706
    return s.hexdigest()
577
707
 
578
708
 
579
 
def sha_string(f):
580
 
    s = sha.new()
581
 
    s.update(f)
582
 
    return s.hexdigest()
 
709
def sha_string(f, _factory=sha):
 
710
    return _factory(f).hexdigest()
583
711
 
584
712
 
585
713
def fingerprint_file(f):
586
 
    s = sha.new()
587
714
    b = f.read()
588
 
    s.update(b)
589
 
    size = len(b)
590
 
    return {'size': size,
591
 
            'sha1': s.hexdigest()}
 
715
    return {'size': len(b),
 
716
            'sha1': sha(b).hexdigest()}
592
717
 
593
718
 
594
719
def compare_files(a, b):
610
735
    offset = datetime.fromtimestamp(t) - datetime.utcfromtimestamp(t)
611
736
    return offset.days * 86400 + offset.seconds
612
737
 
613
 
    
 
738
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
 
739
_default_format_by_weekday_num = [wd + " %Y-%m-%d %H:%M:%S" for wd in weekdays]
 
740
 
 
741
 
614
742
def format_date(t, offset=0, timezone='original', date_fmt=None,
615
743
                show_offset=True):
616
744
    """Return a formatted date string.
620
748
    :param timezone: How to display the time: 'utc', 'original' for the
621
749
         timezone specified by offset, or 'local' for the process's current
622
750
         timezone.
623
 
    :param show_offset: Whether to append the timezone.
624
 
    :param date_fmt: strftime format.
625
 
    """
 
751
    :param date_fmt: strftime format.
 
752
    :param show_offset: Whether to append the timezone.
 
753
    """
 
754
    (date_fmt, tt, offset_str) = \
 
755
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
756
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
 
757
    date_str = time.strftime(date_fmt, tt)
 
758
    return date_str + offset_str
 
759
 
 
760
 
 
761
# Cache of formatted offset strings
 
762
_offset_cache = {}
 
763
 
 
764
 
 
765
def format_date_with_offset_in_original_timezone(t, offset=0,
 
766
    _cache=_offset_cache):
 
767
    """Return a formatted date string in the original timezone.
 
768
 
 
769
    This routine may be faster then format_date.
 
770
 
 
771
    :param t: Seconds since the epoch.
 
772
    :param offset: Timezone offset in seconds east of utc.
 
773
    """
 
774
    if offset is None:
 
775
        offset = 0
 
776
    tt = time.gmtime(t + offset)
 
777
    date_fmt = _default_format_by_weekday_num[tt[6]]
 
778
    date_str = time.strftime(date_fmt, tt)
 
779
    offset_str = _cache.get(offset, None)
 
780
    if offset_str is None:
 
781
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
 
782
        _cache[offset] = offset_str
 
783
    return date_str + offset_str
 
784
 
 
785
 
 
786
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
 
787
                      show_offset=True):
 
788
    """Return an unicode date string formatted according to the current locale.
 
789
 
 
790
    :param t: Seconds since the epoch.
 
791
    :param offset: Timezone offset in seconds east of utc.
 
792
    :param timezone: How to display the time: 'utc', 'original' for the
 
793
         timezone specified by offset, or 'local' for the process's current
 
794
         timezone.
 
795
    :param date_fmt: strftime format.
 
796
    :param show_offset: Whether to append the timezone.
 
797
    """
 
798
    (date_fmt, tt, offset_str) = \
 
799
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
800
    date_str = time.strftime(date_fmt, tt)
 
801
    if not isinstance(date_str, unicode):
 
802
        date_str = date_str.decode(get_user_encoding(), 'replace')
 
803
    return date_str + offset_str
 
804
 
 
805
 
 
806
def _format_date(t, offset, timezone, date_fmt, show_offset):
626
807
    if timezone == 'utc':
627
808
        tt = time.gmtime(t)
628
809
        offset = 0
634
815
        tt = time.localtime(t)
635
816
        offset = local_time_offset(t)
636
817
    else:
637
 
        raise errors.BzrError("unsupported timezone format %r" % timezone,
638
 
                              ['options are "utc", "original", "local"'])
 
818
        raise errors.UnsupportedTimezoneFormat(timezone)
639
819
    if date_fmt is None:
640
820
        date_fmt = "%a %Y-%m-%d %H:%M:%S"
641
821
    if show_offset:
642
822
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
643
823
    else:
644
824
        offset_str = ''
645
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
825
    return (date_fmt, tt, offset_str)
646
826
 
647
827
 
648
828
def compact_date(when):
649
829
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
650
 
    
 
830
 
651
831
 
652
832
def format_delta(delta):
653
833
    """Get a nice looking string for a time delta.
729
909
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
730
910
def rand_chars(num):
731
911
    """Return a random string of num alphanumeric characters
732
 
    
733
 
    The result only contains lowercase chars because it may be used on 
 
912
 
 
913
    The result only contains lowercase chars because it may be used on
734
914
    case-insensitive filesystems.
735
915
    """
736
916
    s = ''
744
924
 
745
925
def splitpath(p):
746
926
    """Turn string into list of parts."""
747
 
    assert isinstance(p, basestring)
748
 
 
749
927
    # split on either delimiter because people might use either on
750
928
    # Windows
751
929
    ps = re.split(r'[\\/]', p)
760
938
            rps.append(f)
761
939
    return rps
762
940
 
 
941
 
763
942
def joinpath(p):
764
 
    assert isinstance(p, (list, tuple))
765
943
    for f in p:
766
944
        if (f == '..') or (f is None) or (f == ''):
767
945
            raise errors.BzrError("sorry, %r not allowed in path" % f)
768
946
    return pathjoin(*p)
769
947
 
770
948
 
771
 
@deprecated_function(zero_nine)
772
 
def appendpath(p1, p2):
773
 
    if p1 == '':
774
 
        return p2
775
 
    else:
776
 
        return pathjoin(p1, p2)
777
 
    
 
949
def parent_directories(filename):
 
950
    """Return the list of parent directories, deepest first.
 
951
    
 
952
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
 
953
    """
 
954
    parents = []
 
955
    parts = splitpath(dirname(filename))
 
956
    while parts:
 
957
        parents.append(joinpath(parts))
 
958
        parts.pop()
 
959
    return parents
 
960
 
 
961
 
 
962
_extension_load_failures = []
 
963
 
 
964
 
 
965
def failed_to_load_extension(exception):
 
966
    """Handle failing to load a binary extension.
 
967
 
 
968
    This should be called from the ImportError block guarding the attempt to
 
969
    import the native extension.  If this function returns, the pure-Python
 
970
    implementation should be loaded instead::
 
971
 
 
972
    >>> try:
 
973
    >>>     import bzrlib._fictional_extension_pyx
 
974
    >>> except ImportError, e:
 
975
    >>>     bzrlib.osutils.failed_to_load_extension(e)
 
976
    >>>     import bzrlib._fictional_extension_py
 
977
    """
 
978
    # NB: This docstring is just an example, not a doctest, because doctest
 
979
    # currently can't cope with the use of lazy imports in this namespace --
 
980
    # mbp 20090729
 
981
    
 
982
    # This currently doesn't report the failure at the time it occurs, because
 
983
    # they tend to happen very early in startup when we can't check config
 
984
    # files etc, and also we want to report all failures but not spam the user
 
985
    # with 10 warnings.
 
986
    from bzrlib import trace
 
987
    exception_str = str(exception)
 
988
    if exception_str not in _extension_load_failures:
 
989
        trace.mutter("failed to load compiled extension: %s" % exception_str)
 
990
        _extension_load_failures.append(exception_str)
 
991
 
 
992
 
 
993
def report_extension_load_failures():
 
994
    if not _extension_load_failures:
 
995
        return
 
996
    from bzrlib.config import GlobalConfig
 
997
    if GlobalConfig().get_user_option_as_bool('ignore_missing_extensions'):
 
998
        return
 
999
    # the warnings framework should by default show this only once
 
1000
    from bzrlib.trace import warning
 
1001
    warning(
 
1002
        "bzr: warning: some compiled extensions could not be loaded; "
 
1003
        "see <https://answers.launchpad.net/bzr/+faq/703>")
 
1004
    # we no longer show the specific missing extensions here, because it makes
 
1005
    # the message too long and scary - see
 
1006
    # https://bugs.launchpad.net/bzr/+bug/430529
 
1007
 
 
1008
 
 
1009
try:
 
1010
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
1011
except ImportError, e:
 
1012
    failed_to_load_extension(e)
 
1013
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
1014
 
778
1015
 
779
1016
def split_lines(s):
780
1017
    """Split s into lines, but without removing the newline characters."""
 
1018
    # Trivially convert a fulltext into a 'chunked' representation, and let
 
1019
    # chunks_to_lines do the heavy lifting.
 
1020
    if isinstance(s, str):
 
1021
        # chunks_to_lines only supports 8-bit strings
 
1022
        return chunks_to_lines([s])
 
1023
    else:
 
1024
        return _split_lines(s)
 
1025
 
 
1026
 
 
1027
def _split_lines(s):
 
1028
    """Split s into lines, but without removing the newline characters.
 
1029
 
 
1030
    This supports Unicode or plain string objects.
 
1031
    """
781
1032
    lines = s.split('\n')
782
1033
    result = [line + '\n' for line in lines[:-1]]
783
1034
    if lines[-1]:
801
1052
            raise
802
1053
        shutil.copyfile(src, dest)
803
1054
 
804
 
def delete_any(full_path):
805
 
    """Delete a file or directory."""
 
1055
 
 
1056
def delete_any(path):
 
1057
    """Delete a file, symlink or directory.  
 
1058
    
 
1059
    Will delete even if readonly.
 
1060
    """
806
1061
    try:
807
 
        os.unlink(full_path)
808
 
    except OSError, e:
809
 
    # We may be renaming a dangling inventory id
810
 
        if e.errno not in (errno.EISDIR, errno.EACCES, errno.EPERM):
 
1062
       _delete_file_or_dir(path)
 
1063
    except (OSError, IOError), e:
 
1064
        if e.errno in (errno.EPERM, errno.EACCES):
 
1065
            # make writable and try again
 
1066
            try:
 
1067
                make_writable(path)
 
1068
            except (OSError, IOError):
 
1069
                pass
 
1070
            _delete_file_or_dir(path)
 
1071
        else:
811
1072
            raise
812
 
        os.rmdir(full_path)
 
1073
 
 
1074
 
 
1075
def _delete_file_or_dir(path):
 
1076
    # Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
1077
    # Forgiveness than Permission (EAFP) because:
 
1078
    # - root can damage a solaris file system by using unlink,
 
1079
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
1080
    #   EACCES, OSX: EPERM) when invoked on a directory.
 
1081
    if isdir(path): # Takes care of symlinks
 
1082
        os.rmdir(path)
 
1083
    else:
 
1084
        os.unlink(path)
813
1085
 
814
1086
 
815
1087
def has_symlinks():
817
1089
        return True
818
1090
    else:
819
1091
        return False
820
 
        
 
1092
 
 
1093
 
 
1094
def has_hardlinks():
 
1095
    if getattr(os, 'link', None) is not None:
 
1096
        return True
 
1097
    else:
 
1098
        return False
 
1099
 
 
1100
 
 
1101
def host_os_dereferences_symlinks():
 
1102
    return (has_symlinks()
 
1103
            and sys.platform not in ('cygwin', 'win32'))
 
1104
 
 
1105
 
 
1106
def readlink(abspath):
 
1107
    """Return a string representing the path to which the symbolic link points.
 
1108
 
 
1109
    :param abspath: The link absolute unicode path.
 
1110
 
 
1111
    This his guaranteed to return the symbolic link in unicode in all python
 
1112
    versions.
 
1113
    """
 
1114
    link = abspath.encode(_fs_enc)
 
1115
    target = os.readlink(link)
 
1116
    target = target.decode(_fs_enc)
 
1117
    return target
 
1118
 
821
1119
 
822
1120
def contains_whitespace(s):
823
1121
    """True if there are any whitespace characters in s."""
849
1147
 
850
1148
 
851
1149
def relpath(base, path):
852
 
    """Return path relative to base, or raise exception.
 
1150
    """Return path relative to base, or raise PathNotChild exception.
853
1151
 
854
1152
    The path may be either an absolute path or a path relative to the
855
1153
    current working directory.
857
1155
    os.path.commonprefix (python2.4) has a bad bug that it works just
858
1156
    on string prefixes, assuming that '/u' is a prefix of '/u2'.  This
859
1157
    avoids that problem.
 
1158
 
 
1159
    NOTE: `base` should not have a trailing slash otherwise you'll get
 
1160
    PathNotChild exceptions regardless of `path`.
860
1161
    """
861
1162
 
862
 
    assert len(base) >= MIN_ABS_PATHLENGTH, ('Length of base must be equal or'
863
 
        ' exceed the platform minimum length (which is %d)' % 
864
 
        MIN_ABS_PATHLENGTH)
 
1163
    if len(base) < MIN_ABS_PATHLENGTH:
 
1164
        # must have space for e.g. a drive letter
 
1165
        raise ValueError('%r is too short to calculate a relative path'
 
1166
            % (base,))
865
1167
 
866
1168
    rp = abspath(path)
867
1169
 
868
1170
    s = []
869
1171
    head = rp
870
 
    while len(head) >= len(base):
 
1172
    while True:
 
1173
        if len(head) <= len(base) and head != base:
 
1174
            raise errors.PathNotChild(rp, base)
871
1175
        if head == base:
872
1176
            break
873
 
        head, tail = os.path.split(head)
 
1177
        head, tail = split(head)
874
1178
        if tail:
875
 
            s.insert(0, tail)
876
 
    else:
877
 
        raise errors.PathNotChild(rp, base)
 
1179
            s.append(tail)
878
1180
 
879
1181
    if s:
880
 
        return pathjoin(*s)
 
1182
        return pathjoin(*reversed(s))
881
1183
    else:
882
1184
        return ''
883
1185
 
884
1186
 
 
1187
def _cicp_canonical_relpath(base, path):
 
1188
    """Return the canonical path relative to base.
 
1189
 
 
1190
    Like relpath, but on case-insensitive-case-preserving file-systems, this
 
1191
    will return the relpath as stored on the file-system rather than in the
 
1192
    case specified in the input string, for all existing portions of the path.
 
1193
 
 
1194
    This will cause O(N) behaviour if called for every path in a tree; if you
 
1195
    have a number of paths to convert, you should use canonical_relpaths().
 
1196
    """
 
1197
    # TODO: it should be possible to optimize this for Windows by using the
 
1198
    # win32 API FindFiles function to look for the specified name - but using
 
1199
    # os.listdir() still gives us the correct, platform agnostic semantics in
 
1200
    # the short term.
 
1201
 
 
1202
    rel = relpath(base, path)
 
1203
    # '.' will have been turned into ''
 
1204
    if not rel:
 
1205
        return rel
 
1206
 
 
1207
    abs_base = abspath(base)
 
1208
    current = abs_base
 
1209
    _listdir = os.listdir
 
1210
 
 
1211
    # use an explicit iterator so we can easily consume the rest on early exit.
 
1212
    bit_iter = iter(rel.split('/'))
 
1213
    for bit in bit_iter:
 
1214
        lbit = bit.lower()
 
1215
        try:
 
1216
            next_entries = _listdir(current)
 
1217
        except OSError: # enoent, eperm, etc
 
1218
            # We can't find this in the filesystem, so just append the
 
1219
            # remaining bits.
 
1220
            current = pathjoin(current, bit, *list(bit_iter))
 
1221
            break
 
1222
        for look in next_entries:
 
1223
            if lbit == look.lower():
 
1224
                current = pathjoin(current, look)
 
1225
                break
 
1226
        else:
 
1227
            # got to the end, nothing matched, so we just return the
 
1228
            # non-existing bits as they were specified (the filename may be
 
1229
            # the target of a move, for example).
 
1230
            current = pathjoin(current, bit, *list(bit_iter))
 
1231
            break
 
1232
    return current[len(abs_base):].lstrip('/')
 
1233
 
 
1234
# XXX - TODO - we need better detection/integration of case-insensitive
 
1235
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
 
1236
# filesystems), for example, so could probably benefit from the same basic
 
1237
# support there.  For now though, only Windows and OSX get that support, and
 
1238
# they get it for *all* file-systems!
 
1239
if sys.platform in ('win32', 'darwin'):
 
1240
    canonical_relpath = _cicp_canonical_relpath
 
1241
else:
 
1242
    canonical_relpath = relpath
 
1243
 
 
1244
def canonical_relpaths(base, paths):
 
1245
    """Create an iterable to canonicalize a sequence of relative paths.
 
1246
 
 
1247
    The intent is for this implementation to use a cache, vastly speeding
 
1248
    up multiple transformations in the same directory.
 
1249
    """
 
1250
    # but for now, we haven't optimized...
 
1251
    return [canonical_relpath(base, p) for p in paths]
 
1252
 
885
1253
def safe_unicode(unicode_or_utf8_string):
886
1254
    """Coerce unicode_or_utf8_string into unicode.
887
1255
 
888
1256
    If it is unicode, it is returned.
889
 
    Otherwise it is decoded from utf-8. If a decoding error
890
 
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
891
 
    as a BzrBadParameter exception.
 
1257
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
 
1258
    wrapped in a BzrBadParameterNotUnicode exception.
892
1259
    """
893
1260
    if isinstance(unicode_or_utf8_string, unicode):
894
1261
        return unicode_or_utf8_string
981
1348
 
982
1349
    On platforms where the system normalizes filenames (Mac OSX),
983
1350
    you can access a file by any path which will normalize correctly.
984
 
    On platforms where the system does not normalize filenames 
 
1351
    On platforms where the system does not normalize filenames
985
1352
    (Windows, Linux), you have to access a file by its exact path.
986
1353
 
987
 
    Internally, bzr only supports NFC/NFKC normalization, since that is 
 
1354
    Internally, bzr only supports NFC normalization, since that is
988
1355
    the standard for XML documents.
989
1356
 
990
1357
    So return the normalized path, and a flag indicating if the file
991
1358
    can be accessed by that path.
992
1359
    """
993
1360
 
994
 
    return unicodedata.normalize('NFKC', unicode(path)), True
 
1361
    return unicodedata.normalize('NFC', unicode(path)), True
995
1362
 
996
1363
 
997
1364
def _inaccessible_normalized_filename(path):
998
1365
    __doc__ = _accessible_normalized_filename.__doc__
999
1366
 
1000
 
    normalized = unicodedata.normalize('NFKC', unicode(path))
 
1367
    normalized = unicodedata.normalize('NFC', unicode(path))
1001
1368
    return normalized, normalized == path
1002
1369
 
1003
1370
 
1007
1374
    normalized_filename = _inaccessible_normalized_filename
1008
1375
 
1009
1376
 
 
1377
def set_signal_handler(signum, handler, restart_syscall=True):
 
1378
    """A wrapper for signal.signal that also calls siginterrupt(signum, False)
 
1379
    on platforms that support that.
 
1380
 
 
1381
    :param restart_syscall: if set, allow syscalls interrupted by a signal to
 
1382
        automatically restart (by calling `signal.siginterrupt(signum,
 
1383
        False)`).  May be ignored if the feature is not available on this
 
1384
        platform or Python version.
 
1385
    """
 
1386
    try:
 
1387
        import signal
 
1388
        siginterrupt = signal.siginterrupt
 
1389
    except ImportError:
 
1390
        # This python implementation doesn't provide signal support, hence no
 
1391
        # handler exists
 
1392
        return None
 
1393
    except AttributeError:
 
1394
        # siginterrupt doesn't exist on this platform, or for this version
 
1395
        # of Python.
 
1396
        siginterrupt = lambda signum, flag: None
 
1397
    if restart_syscall:
 
1398
        def sig_handler(*args):
 
1399
            # Python resets the siginterrupt flag when a signal is
 
1400
            # received.  <http://bugs.python.org/issue8354>
 
1401
            # As a workaround for some cases, set it back the way we want it.
 
1402
            siginterrupt(signum, False)
 
1403
            # Now run the handler function passed to set_signal_handler.
 
1404
            handler(*args)
 
1405
    else:
 
1406
        sig_handler = handler
 
1407
    old_handler = signal.signal(signum, sig_handler)
 
1408
    if restart_syscall:
 
1409
        siginterrupt(signum, False)
 
1410
    return old_handler
 
1411
 
 
1412
 
 
1413
default_terminal_width = 80
 
1414
"""The default terminal width for ttys.
 
1415
 
 
1416
This is defined so that higher levels can share a common fallback value when
 
1417
terminal_width() returns None.
 
1418
"""
 
1419
 
 
1420
 
1010
1421
def terminal_width():
1011
 
    """Return estimated terminal width."""
1012
 
    if sys.platform == 'win32':
1013
 
        return win32utils.get_console_size()[0]
1014
 
    width = 0
 
1422
    """Return terminal width.
 
1423
 
 
1424
    None is returned if the width can't established precisely.
 
1425
 
 
1426
    The rules are:
 
1427
    - if BZR_COLUMNS is set, returns its value
 
1428
    - if there is no controlling terminal, returns None
 
1429
    - if COLUMNS is set, returns its value,
 
1430
 
 
1431
    From there, we need to query the OS to get the size of the controlling
 
1432
    terminal.
 
1433
 
 
1434
    Unices:
 
1435
    - get termios.TIOCGWINSZ
 
1436
    - if an error occurs or a negative value is obtained, returns None
 
1437
 
 
1438
    Windows:
 
1439
    
 
1440
    - win32utils.get_console_size() decides,
 
1441
    - returns None on error (provided default value)
 
1442
    """
 
1443
 
 
1444
    # If BZR_COLUMNS is set, take it, user is always right
 
1445
    try:
 
1446
        return int(os.environ['BZR_COLUMNS'])
 
1447
    except (KeyError, ValueError):
 
1448
        pass
 
1449
 
 
1450
    isatty = getattr(sys.stdout, 'isatty', None)
 
1451
    if  isatty is None or not isatty():
 
1452
        # Don't guess, setting BZR_COLUMNS is the recommended way to override.
 
1453
        return None
 
1454
 
 
1455
    # If COLUMNS is set, take it, the terminal knows better (even inside a
 
1456
    # given terminal, the application can decide to set COLUMNS to a lower
 
1457
    # value (splitted screen) or a bigger value (scroll bars))
 
1458
    try:
 
1459
        return int(os.environ['COLUMNS'])
 
1460
    except (KeyError, ValueError):
 
1461
        pass
 
1462
 
 
1463
    width, height = _terminal_size(None, None)
 
1464
    if width <= 0:
 
1465
        # Consider invalid values as meaning no width
 
1466
        return None
 
1467
 
 
1468
    return width
 
1469
 
 
1470
 
 
1471
def _win32_terminal_size(width, height):
 
1472
    width, height = win32utils.get_console_size(defaultx=width, defaulty=height)
 
1473
    return width, height
 
1474
 
 
1475
 
 
1476
def _ioctl_terminal_size(width, height):
1015
1477
    try:
1016
1478
        import struct, fcntl, termios
1017
1479
        s = struct.pack('HHHH', 0, 0, 0, 0)
1018
1480
        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
1019
 
        width = struct.unpack('HHHH', x)[1]
1020
 
    except IOError:
 
1481
        height, width = struct.unpack('HHHH', x)[0:2]
 
1482
    except (IOError, AttributeError):
1021
1483
        pass
1022
 
    if width <= 0:
 
1484
    return width, height
 
1485
 
 
1486
_terminal_size = None
 
1487
"""Returns the terminal size as (width, height).
 
1488
 
 
1489
:param width: Default value for width.
 
1490
:param height: Default value for height.
 
1491
 
 
1492
This is defined specifically for each OS and query the size of the controlling
 
1493
terminal. If any error occurs, the provided default values should be returned.
 
1494
"""
 
1495
if sys.platform == 'win32':
 
1496
    _terminal_size = _win32_terminal_size
 
1497
else:
 
1498
    _terminal_size = _ioctl_terminal_size
 
1499
 
 
1500
 
 
1501
def _terminal_size_changed(signum, frame):
 
1502
    """Set COLUMNS upon receiving a SIGnal for WINdow size CHange."""
 
1503
    width, height = _terminal_size(None, None)
 
1504
    if width is not None:
 
1505
        os.environ['COLUMNS'] = str(width)
 
1506
 
 
1507
 
 
1508
_registered_sigwinch = False
 
1509
def watch_sigwinch():
 
1510
    """Register for SIGWINCH, once and only once.
 
1511
 
 
1512
    Do nothing if the signal module is not available.
 
1513
    """
 
1514
    global _registered_sigwinch
 
1515
    if not _registered_sigwinch:
1023
1516
        try:
1024
 
            width = int(os.environ['COLUMNS'])
1025
 
        except:
 
1517
            import signal
 
1518
            if getattr(signal, "SIGWINCH", None) is not None:
 
1519
                set_signal_handler(signal.SIGWINCH, _terminal_size_changed)
 
1520
        except ImportError:
 
1521
            # python doesn't provide signal support, nothing we can do about it
1026
1522
            pass
1027
 
    if width <= 0:
1028
 
        width = 80
1029
 
 
1030
 
    return width
 
1523
        _registered_sigwinch = True
1031
1524
 
1032
1525
 
1033
1526
def supports_executable():
1061
1554
            del os.environ[env_variable]
1062
1555
    else:
1063
1556
        if isinstance(value, unicode):
1064
 
            value = value.encode(bzrlib.user_encoding)
 
1557
            value = value.encode(get_user_encoding())
1065
1558
        os.environ[env_variable] = value
1066
1559
    return orig_val
1067
1560
 
1070
1563
 
1071
1564
 
1072
1565
def check_legal_path(path):
1073
 
    """Check whether the supplied path is legal.  
 
1566
    """Check whether the supplied path is legal.
1074
1567
    This is only required on Windows, so we don't test on other platforms
1075
1568
    right now.
1076
1569
    """
1080
1573
        raise errors.IllegalPath(path)
1081
1574
 
1082
1575
 
 
1576
_WIN32_ERROR_DIRECTORY = 267 # Similar to errno.ENOTDIR
 
1577
 
 
1578
def _is_error_enotdir(e):
 
1579
    """Check if this exception represents ENOTDIR.
 
1580
 
 
1581
    Unfortunately, python is very inconsistent about the exception
 
1582
    here. The cases are:
 
1583
      1) Linux, Mac OSX all versions seem to set errno == ENOTDIR
 
1584
      2) Windows, Python2.4, uses errno == ERROR_DIRECTORY (267)
 
1585
         which is the windows error code.
 
1586
      3) Windows, Python2.5 uses errno == EINVAL and
 
1587
         winerror == ERROR_DIRECTORY
 
1588
 
 
1589
    :param e: An Exception object (expected to be OSError with an errno
 
1590
        attribute, but we should be able to cope with anything)
 
1591
    :return: True if this represents an ENOTDIR error. False otherwise.
 
1592
    """
 
1593
    en = getattr(e, 'errno', None)
 
1594
    if (en == errno.ENOTDIR
 
1595
        or (sys.platform == 'win32'
 
1596
            and (en == _WIN32_ERROR_DIRECTORY
 
1597
                 or (en == errno.EINVAL
 
1598
                     and getattr(e, 'winerror', None) == _WIN32_ERROR_DIRECTORY)
 
1599
        ))):
 
1600
        return True
 
1601
    return False
 
1602
 
 
1603
 
1083
1604
def walkdirs(top, prefix=""):
1084
1605
    """Yield data about all the directories in a tree.
1085
 
    
 
1606
 
1086
1607
    This yields all the data about the contents of a directory at a time.
1087
1608
    After each directory has been yielded, if the caller has mutated the list
1088
1609
    to exclude some directories, they are then not descended into.
1089
 
    
 
1610
 
1090
1611
    The data yielded is of the form:
1091
1612
    ((directory-relpath, directory-path-from-top),
1092
 
    [(directory-relpath, basename, kind, lstat, path-from-top), ...]),
 
1613
    [(relpath, basename, kind, lstat, path-from-top), ...]),
1093
1614
     - directory-relpath is the relative path of the directory being returned
1094
1615
       with respect to top. prefix is prepended to this.
1095
 
     - directory-path-from-root is the path including top for this directory. 
 
1616
     - directory-path-from-root is the path including top for this directory.
1096
1617
       It is suitable for use with os functions.
1097
1618
     - relpath is the relative path within the subtree being walked.
1098
1619
     - basename is the basename of the path
1100
1621
       present within the tree - but it may be recorded as versioned. See
1101
1622
       versioned_kind.
1102
1623
     - lstat is the stat data *if* the file was statted.
1103
 
     - planned, not implemented: 
 
1624
     - planned, not implemented:
1104
1625
       path_from_tree_root is the path from the root of the tree.
1105
1626
 
1106
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
 
1627
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1107
1628
        allows one to walk a subtree but get paths that are relative to a tree
1108
1629
        rooted higher up.
1109
1630
    :return: an iterator over the dirs.
1110
1631
    """
1111
1632
    #TODO there is a bit of a smell where the results of the directory-
1112
 
    # summary in this, and the path from the root, may not agree 
 
1633
    # summary in this, and the path from the root, may not agree
1113
1634
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1114
1635
    # potentially confusing output. We should make this more robust - but
1115
1636
    # not at a speed cost. RBC 20060731
1116
1637
    _lstat = os.lstat
1117
1638
    _directory = _directory_kind
1118
1639
    _listdir = os.listdir
1119
 
    _kind_from_mode = _formats.get
 
1640
    _kind_from_mode = file_kind_from_stat_mode
1120
1641
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
1121
1642
    while pending:
1122
1643
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1129
1650
 
1130
1651
        dirblock = []
1131
1652
        append = dirblock.append
1132
 
        for name in sorted(_listdir(top)):
1133
 
            abspath = top_slash + name
1134
 
            statvalue = _lstat(abspath)
1135
 
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1136
 
            append((relprefix + name, name, kind, statvalue, abspath))
 
1653
        try:
 
1654
            names = sorted(_listdir(top))
 
1655
        except OSError, e:
 
1656
            if not _is_error_enotdir(e):
 
1657
                raise
 
1658
        else:
 
1659
            for name in names:
 
1660
                abspath = top_slash + name
 
1661
                statvalue = _lstat(abspath)
 
1662
                kind = _kind_from_mode(statvalue.st_mode)
 
1663
                append((relprefix + name, name, kind, statvalue, abspath))
1137
1664
        yield (relroot, top), dirblock
1138
1665
 
1139
1666
        # push the user specified dirs from dirblock
1140
1667
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1141
1668
 
1142
1669
 
 
1670
class DirReader(object):
 
1671
    """An interface for reading directories."""
 
1672
 
 
1673
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1674
        """Converts top and prefix to a starting dir entry
 
1675
 
 
1676
        :param top: A utf8 path
 
1677
        :param prefix: An optional utf8 path to prefix output relative paths
 
1678
            with.
 
1679
        :return: A tuple starting with prefix, and ending with the native
 
1680
            encoding of top.
 
1681
        """
 
1682
        raise NotImplementedError(self.top_prefix_to_starting_dir)
 
1683
 
 
1684
    def read_dir(self, prefix, top):
 
1685
        """Read a specific dir.
 
1686
 
 
1687
        :param prefix: A utf8 prefix to be preprended to the path basenames.
 
1688
        :param top: A natively encoded path to read.
 
1689
        :return: A list of the directories contents. Each item contains:
 
1690
            (utf8_relpath, utf8_name, kind, lstatvalue, native_abspath)
 
1691
        """
 
1692
        raise NotImplementedError(self.read_dir)
 
1693
 
 
1694
 
 
1695
_selected_dir_reader = None
 
1696
 
 
1697
 
1143
1698
def _walkdirs_utf8(top, prefix=""):
1144
1699
    """Yield data about all the directories in a tree.
1145
1700
 
1154
1709
        path-from-top might be unicode or utf8, but it is the correct path to
1155
1710
        pass to os functions to affect the file in question. (such as os.lstat)
1156
1711
    """
1157
 
    fs_encoding = _fs_enc.upper()
1158
 
    if (sys.platform == 'win32' or
1159
 
        fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968')): # ascii
1160
 
        return _walkdirs_unicode_to_utf8(top, prefix=prefix)
1161
 
    else:
1162
 
        return _walkdirs_fs_utf8(top, prefix=prefix)
1163
 
 
1164
 
 
1165
 
def _walkdirs_fs_utf8(top, prefix=""):
1166
 
    """See _walkdirs_utf8.
1167
 
 
1168
 
    This sub-function is called when we know the filesystem is already in utf8
1169
 
    encoding. So we don't need to transcode filenames.
1170
 
    """
1171
 
    _lstat = os.lstat
1172
 
    _directory = _directory_kind
1173
 
    _listdir = os.listdir
1174
 
    _kind_from_mode = _formats.get
 
1712
    global _selected_dir_reader
 
1713
    if _selected_dir_reader is None:
 
1714
        fs_encoding = _fs_enc.upper()
 
1715
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
 
1716
            # Win98 doesn't have unicode apis like FindFirstFileW
 
1717
            # TODO: We possibly could support Win98 by falling back to the
 
1718
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
 
1719
            #       but that gets a bit tricky, and requires custom compiling
 
1720
            #       for win98 anyway.
 
1721
            try:
 
1722
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1723
                _selected_dir_reader = Win32ReadDir()
 
1724
            except ImportError:
 
1725
                pass
 
1726
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1727
            # ANSI_X3.4-1968 is a form of ASCII
 
1728
            try:
 
1729
                from bzrlib._readdir_pyx import UTF8DirReader
 
1730
                _selected_dir_reader = UTF8DirReader()
 
1731
            except ImportError, e:
 
1732
                failed_to_load_extension(e)
 
1733
                pass
 
1734
 
 
1735
    if _selected_dir_reader is None:
 
1736
        # Fallback to the python version
 
1737
        _selected_dir_reader = UnicodeDirReader()
1175
1738
 
1176
1739
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1177
1740
    # But we don't actually uses 1-3 in pending, so set them to None
1178
 
    pending = [(safe_utf8(prefix), None, None, None, safe_utf8(top))]
 
1741
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
 
1742
    read_dir = _selected_dir_reader.read_dir
 
1743
    _directory = _directory_kind
1179
1744
    while pending:
1180
 
        relroot, _, _, _, top = pending.pop()
1181
 
        if relroot:
1182
 
            relprefix = relroot + '/'
1183
 
        else:
1184
 
            relprefix = ''
1185
 
        top_slash = top + '/'
1186
 
 
1187
 
        dirblock = []
1188
 
        append = dirblock.append
1189
 
        for name in sorted(_listdir(top)):
1190
 
            abspath = top_slash + name
1191
 
            statvalue = _lstat(abspath)
1192
 
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1193
 
            append((relprefix + name, name, kind, statvalue, abspath))
 
1745
        relroot, _, _, _, top = pending[-1].pop()
 
1746
        if not pending[-1]:
 
1747
            pending.pop()
 
1748
        dirblock = sorted(read_dir(relroot, top))
1194
1749
        yield (relroot, top), dirblock
1195
 
 
1196
1750
        # push the user specified dirs from dirblock
1197
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1198
 
 
1199
 
 
1200
 
def _walkdirs_unicode_to_utf8(top, prefix=""):
1201
 
    """See _walkdirs_utf8
1202
 
 
1203
 
    Because Win32 has a Unicode api, all of the 'path-from-top' entries will be
1204
 
    Unicode paths.
1205
 
    This is currently the fallback code path when the filesystem encoding is
1206
 
    not UTF-8. It may be better to implement an alternative so that we can
1207
 
    safely handle paths that are not properly decodable in the current
1208
 
    encoding.
1209
 
    """
1210
 
    _utf8_encode = codecs.getencoder('utf8')
1211
 
    _lstat = os.lstat
1212
 
    _directory = _directory_kind
1213
 
    _listdir = os.listdir
1214
 
    _kind_from_mode = _formats.get
1215
 
 
1216
 
    pending = [(safe_utf8(prefix), None, None, None, safe_unicode(top))]
1217
 
    while pending:
1218
 
        relroot, _, _, _, top = pending.pop()
1219
 
        if relroot:
1220
 
            relprefix = relroot + '/'
 
1751
        next = [d for d in reversed(dirblock) if d[2] == _directory]
 
1752
        if next:
 
1753
            pending.append(next)
 
1754
 
 
1755
 
 
1756
class UnicodeDirReader(DirReader):
 
1757
    """A dir reader for non-utf8 file systems, which transcodes."""
 
1758
 
 
1759
    __slots__ = ['_utf8_encode']
 
1760
 
 
1761
    def __init__(self):
 
1762
        self._utf8_encode = codecs.getencoder('utf8')
 
1763
 
 
1764
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1765
        """See DirReader.top_prefix_to_starting_dir."""
 
1766
        return (safe_utf8(prefix), None, None, None, safe_unicode(top))
 
1767
 
 
1768
    def read_dir(self, prefix, top):
 
1769
        """Read a single directory from a non-utf8 file system.
 
1770
 
 
1771
        top, and the abspath element in the output are unicode, all other paths
 
1772
        are utf8. Local disk IO is done via unicode calls to listdir etc.
 
1773
 
 
1774
        This is currently the fallback code path when the filesystem encoding is
 
1775
        not UTF-8. It may be better to implement an alternative so that we can
 
1776
        safely handle paths that are not properly decodable in the current
 
1777
        encoding.
 
1778
 
 
1779
        See DirReader.read_dir for details.
 
1780
        """
 
1781
        _utf8_encode = self._utf8_encode
 
1782
        _lstat = os.lstat
 
1783
        _listdir = os.listdir
 
1784
        _kind_from_mode = file_kind_from_stat_mode
 
1785
 
 
1786
        if prefix:
 
1787
            relprefix = prefix + '/'
1221
1788
        else:
1222
1789
            relprefix = ''
1223
1790
        top_slash = top + u'/'
1225
1792
        dirblock = []
1226
1793
        append = dirblock.append
1227
1794
        for name in sorted(_listdir(top)):
1228
 
            name_utf8 = _utf8_encode(name)[0]
 
1795
            try:
 
1796
                name_utf8 = _utf8_encode(name)[0]
 
1797
            except UnicodeDecodeError:
 
1798
                raise errors.BadFilenameEncoding(
 
1799
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
1229
1800
            abspath = top_slash + name
1230
1801
            statvalue = _lstat(abspath)
1231
 
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1802
            kind = _kind_from_mode(statvalue.st_mode)
1232
1803
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1233
 
        yield (relroot, top), dirblock
1234
 
 
1235
 
        # push the user specified dirs from dirblock
1236
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1804
        return dirblock
1237
1805
 
1238
1806
 
1239
1807
def copy_tree(from_path, to_path, handlers={}):
1240
1808
    """Copy all of the entries in from_path into to_path.
1241
1809
 
1242
 
    :param from_path: The base directory to copy. 
 
1810
    :param from_path: The base directory to copy.
1243
1811
    :param to_path: The target directory. If it does not exist, it will
1244
1812
        be created.
1245
1813
    :param handlers: A dictionary of functions, which takes a source and
1278
1846
            real_handlers[kind](abspath, relpath)
1279
1847
 
1280
1848
 
 
1849
def copy_ownership_from_path(dst, src=None):
 
1850
    """Copy usr/grp ownership from src file/dir to dst file/dir.
 
1851
 
 
1852
    If src is None, the containing directory is used as source. If chown
 
1853
    fails, the error is ignored and a warning is printed.
 
1854
    """
 
1855
    chown = getattr(os, 'chown', None)
 
1856
    if chown is None:
 
1857
        return
 
1858
 
 
1859
    if src == None:
 
1860
        src = os.path.dirname(dst)
 
1861
        if src == '':
 
1862
            src = '.'
 
1863
 
 
1864
    try:
 
1865
        s = os.stat(src)
 
1866
        chown(dst, s.st_uid, s.st_gid)
 
1867
    except OSError, e:
 
1868
        trace.warning("Unable to copy ownership from '%s' to '%s': IOError: %s." % (src, dst, e))
 
1869
 
 
1870
 
1281
1871
def path_prefix_key(path):
1282
1872
    """Generate a prefix-order path key for path.
1283
1873
 
1314
1904
        return _cached_user_encoding
1315
1905
 
1316
1906
    if sys.platform == 'darwin':
1317
 
        # work around egregious python 2.4 bug
 
1907
        # python locale.getpreferredencoding() always return
 
1908
        # 'mac-roman' on darwin. That's a lie.
1318
1909
        sys.platform = 'posix'
1319
1910
        try:
 
1911
            if os.environ.get('LANG', None) is None:
 
1912
                # If LANG is not set, we end up with 'ascii', which is bad
 
1913
                # ('mac-roman' is more than ascii), so we set a default which
 
1914
                # will give us UTF-8 (which appears to work in all cases on
 
1915
                # OSX). Users are still free to override LANG of course, as
 
1916
                # long as it give us something meaningful. This work-around
 
1917
                # *may* not be needed with python 3k and/or OSX 10.5, but will
 
1918
                # work with them too -- vila 20080908
 
1919
                os.environ['LANG'] = 'en_US.UTF-8'
1320
1920
            import locale
1321
1921
        finally:
1322
1922
            sys.platform = 'darwin'
1337
1937
    # Windows returns 'cp0' to indicate there is no code page. So we'll just
1338
1938
    # treat that as ASCII, and not support printing unicode characters to the
1339
1939
    # console.
1340
 
    if user_encoding in (None, 'cp0'):
 
1940
    #
 
1941
    # For python scripts run under vim, we get '', so also treat that as ASCII
 
1942
    if user_encoding in (None, 'cp0', ''):
1341
1943
        user_encoding = 'ascii'
1342
1944
    else:
1343
1945
        # check encoding
1357
1959
    return user_encoding
1358
1960
 
1359
1961
 
1360
 
def recv_all(socket, bytes):
 
1962
def get_host_name():
 
1963
    """Return the current unicode host name.
 
1964
 
 
1965
    This is meant to be used in place of socket.gethostname() because that
 
1966
    behaves inconsistently on different platforms.
 
1967
    """
 
1968
    if sys.platform == "win32":
 
1969
        import win32utils
 
1970
        return win32utils.get_host_name()
 
1971
    else:
 
1972
        import socket
 
1973
        return socket.gethostname().decode(get_user_encoding())
 
1974
 
 
1975
 
 
1976
# We must not read/write any more than 64k at a time from/to a socket so we
 
1977
# don't risk "no buffer space available" errors on some platforms.  Windows in
 
1978
# particular is likely to throw WSAECONNABORTED or WSAENOBUFS if given too much
 
1979
# data at once.
 
1980
MAX_SOCKET_CHUNK = 64 * 1024
 
1981
 
 
1982
def read_bytes_from_socket(sock, report_activity=None,
 
1983
        max_read_size=MAX_SOCKET_CHUNK):
 
1984
    """Read up to max_read_size of bytes from sock and notify of progress.
 
1985
 
 
1986
    Translates "Connection reset by peer" into file-like EOF (return an
 
1987
    empty string rather than raise an error), and repeats the recv if
 
1988
    interrupted by a signal.
 
1989
    """
 
1990
    while 1:
 
1991
        try:
 
1992
            bytes = sock.recv(max_read_size)
 
1993
        except socket.error, e:
 
1994
            eno = e.args[0]
 
1995
            if eno == getattr(errno, "WSAECONNRESET", errno.ECONNRESET):
 
1996
                # The connection was closed by the other side.  Callers expect
 
1997
                # an empty string to signal end-of-stream.
 
1998
                return ""
 
1999
            elif eno == errno.EINTR:
 
2000
                # Retry the interrupted recv.
 
2001
                continue
 
2002
            raise
 
2003
        else:
 
2004
            if report_activity is not None:
 
2005
                report_activity(len(bytes), 'read')
 
2006
            return bytes
 
2007
 
 
2008
 
 
2009
def recv_all(socket, count):
1361
2010
    """Receive an exact number of bytes.
1362
2011
 
1363
2012
    Regular Socket.recv() may return less than the requested number of bytes,
1364
 
    dependning on what's in the OS buffer.  MSG_WAITALL is not available
 
2013
    depending on what's in the OS buffer.  MSG_WAITALL is not available
1365
2014
    on all platforms, but this should work everywhere.  This will return
1366
2015
    less than the requested amount if the remote end closes.
1367
2016
 
1368
2017
    This isn't optimized and is intended mostly for use in testing.
1369
2018
    """
1370
2019
    b = ''
1371
 
    while len(b) < bytes:
1372
 
        new = socket.recv(bytes - len(b))
 
2020
    while len(b) < count:
 
2021
        new = read_bytes_from_socket(socket, None, count - len(b))
1373
2022
        if new == '':
1374
2023
            break # eof
1375
2024
        b += new
1376
2025
    return b
1377
2026
 
 
2027
 
 
2028
def send_all(sock, bytes, report_activity=None):
 
2029
    """Send all bytes on a socket.
 
2030
 
 
2031
    Breaks large blocks in smaller chunks to avoid buffering limitations on
 
2032
    some platforms, and catches EINTR which may be thrown if the send is
 
2033
    interrupted by a signal.
 
2034
 
 
2035
    This is preferred to socket.sendall(), because it avoids portability bugs
 
2036
    and provides activity reporting.
 
2037
 
 
2038
    :param report_activity: Call this as bytes are read, see
 
2039
        Transport._report_activity
 
2040
    """
 
2041
    sent_total = 0
 
2042
    byte_count = len(bytes)
 
2043
    while sent_total < byte_count:
 
2044
        try:
 
2045
            sent = sock.send(buffer(bytes, sent_total, MAX_SOCKET_CHUNK))
 
2046
        except socket.error, e:
 
2047
            if e.args[0] != errno.EINTR:
 
2048
                raise
 
2049
        else:
 
2050
            sent_total += sent
 
2051
            report_activity(sent, 'write')
 
2052
 
 
2053
 
1378
2054
def dereference_path(path):
1379
2055
    """Determine the real path to a file.
1380
2056
 
1387
2063
    # The pathjoin for '.' is a workaround for Python bug #1213894.
1388
2064
    # (initial path components aren't dereferenced)
1389
2065
    return pathjoin(realpath(pathjoin('.', parent)), base)
 
2066
 
 
2067
 
 
2068
def supports_mapi():
 
2069
    """Return True if we can use MAPI to launch a mail client."""
 
2070
    return sys.platform == "win32"
 
2071
 
 
2072
 
 
2073
def resource_string(package, resource_name):
 
2074
    """Load a resource from a package and return it as a string.
 
2075
 
 
2076
    Note: Only packages that start with bzrlib are currently supported.
 
2077
 
 
2078
    This is designed to be a lightweight implementation of resource
 
2079
    loading in a way which is API compatible with the same API from
 
2080
    pkg_resources. See
 
2081
    http://peak.telecommunity.com/DevCenter/PkgResources#basic-resource-access.
 
2082
    If and when pkg_resources becomes a standard library, this routine
 
2083
    can delegate to it.
 
2084
    """
 
2085
    # Check package name is within bzrlib
 
2086
    if package == "bzrlib":
 
2087
        resource_relpath = resource_name
 
2088
    elif package.startswith("bzrlib."):
 
2089
        package = package[len("bzrlib."):].replace('.', os.sep)
 
2090
        resource_relpath = pathjoin(package, resource_name)
 
2091
    else:
 
2092
        raise errors.BzrError('resource package %s not in bzrlib' % package)
 
2093
 
 
2094
    # Map the resource to a file and read its contents
 
2095
    base = dirname(bzrlib.__file__)
 
2096
    if getattr(sys, 'frozen', None):    # bzr.exe
 
2097
        base = abspath(pathjoin(base, '..', '..'))
 
2098
    filename = pathjoin(base, resource_relpath)
 
2099
    return open(filename, 'rU').read()
 
2100
 
 
2101
 
 
2102
def file_kind_from_stat_mode_thunk(mode):
 
2103
    global file_kind_from_stat_mode
 
2104
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
 
2105
        try:
 
2106
            from bzrlib._readdir_pyx import UTF8DirReader
 
2107
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
 
2108
        except ImportError, e:
 
2109
            # This is one time where we won't warn that an extension failed to
 
2110
            # load. The extension is never available on Windows anyway.
 
2111
            from bzrlib._readdir_py import (
 
2112
                _kind_from_mode as file_kind_from_stat_mode
 
2113
                )
 
2114
    return file_kind_from_stat_mode(mode)
 
2115
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
 
2116
 
 
2117
 
 
2118
def file_kind(f, _lstat=os.lstat):
 
2119
    try:
 
2120
        return file_kind_from_stat_mode(_lstat(f).st_mode)
 
2121
    except OSError, e:
 
2122
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
 
2123
            raise errors.NoSuchFile(f)
 
2124
        raise
 
2125
 
 
2126
 
 
2127
def until_no_eintr(f, *a, **kw):
 
2128
    """Run f(*a, **kw), retrying if an EINTR error occurs.
 
2129
    
 
2130
    WARNING: you must be certain that it is safe to retry the call repeatedly
 
2131
    if EINTR does occur.  This is typically only true for low-level operations
 
2132
    like os.read.  If in any doubt, don't use this.
 
2133
 
 
2134
    Keep in mind that this is not a complete solution to EINTR.  There is
 
2135
    probably code in the Python standard library and other dependencies that
 
2136
    may encounter EINTR if a signal arrives (and there is signal handler for
 
2137
    that signal).  So this function can reduce the impact for IO that bzrlib
 
2138
    directly controls, but it is not a complete solution.
 
2139
    """
 
2140
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
 
2141
    while True:
 
2142
        try:
 
2143
            return f(*a, **kw)
 
2144
        except (IOError, OSError), e:
 
2145
            if e.errno == errno.EINTR:
 
2146
                continue
 
2147
            raise
 
2148
 
 
2149
 
 
2150
def re_compile_checked(re_string, flags=0, where=""):
 
2151
    """Return a compiled re, or raise a sensible error.
 
2152
 
 
2153
    This should only be used when compiling user-supplied REs.
 
2154
 
 
2155
    :param re_string: Text form of regular expression.
 
2156
    :param flags: eg re.IGNORECASE
 
2157
    :param where: Message explaining to the user the context where
 
2158
        it occurred, eg 'log search filter'.
 
2159
    """
 
2160
    # from https://bugs.launchpad.net/bzr/+bug/251352
 
2161
    try:
 
2162
        re_obj = re.compile(re_string, flags)
 
2163
        re_obj.search("")
 
2164
        return re_obj
 
2165
    except re.error, e:
 
2166
        if where:
 
2167
            where = ' in ' + where
 
2168
        # despite the name 'error' is a type
 
2169
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
2170
            % (where, re_string, e))
 
2171
 
 
2172
 
 
2173
if sys.platform == "win32":
 
2174
    import msvcrt
 
2175
    def getchar():
 
2176
        return msvcrt.getch()
 
2177
else:
 
2178
    import tty
 
2179
    import termios
 
2180
    def getchar():
 
2181
        fd = sys.stdin.fileno()
 
2182
        settings = termios.tcgetattr(fd)
 
2183
        try:
 
2184
            tty.setraw(fd)
 
2185
            ch = sys.stdin.read(1)
 
2186
        finally:
 
2187
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
 
2188
        return ch
 
2189
 
 
2190
 
 
2191
if sys.platform == 'linux2':
 
2192
    def _local_concurrency():
 
2193
        concurrency = None
 
2194
        prefix = 'processor'
 
2195
        for line in file('/proc/cpuinfo', 'rb'):
 
2196
            if line.startswith(prefix):
 
2197
                concurrency = int(line[line.find(':')+1:]) + 1
 
2198
        return concurrency
 
2199
elif sys.platform == 'darwin':
 
2200
    def _local_concurrency():
 
2201
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
 
2202
                                stdout=subprocess.PIPE).communicate()[0]
 
2203
elif sys.platform[0:7] == 'freebsd':
 
2204
    def _local_concurrency():
 
2205
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
 
2206
                                stdout=subprocess.PIPE).communicate()[0]
 
2207
elif sys.platform == 'sunos5':
 
2208
    def _local_concurrency():
 
2209
        return subprocess.Popen(['psrinfo', '-p',],
 
2210
                                stdout=subprocess.PIPE).communicate()[0]
 
2211
elif sys.platform == "win32":
 
2212
    def _local_concurrency():
 
2213
        # This appears to return the number of cores.
 
2214
        return os.environ.get('NUMBER_OF_PROCESSORS')
 
2215
else:
 
2216
    def _local_concurrency():
 
2217
        # Who knows ?
 
2218
        return None
 
2219
 
 
2220
 
 
2221
_cached_local_concurrency = None
 
2222
 
 
2223
def local_concurrency(use_cache=True):
 
2224
    """Return how many processes can be run concurrently.
 
2225
 
 
2226
    Rely on platform specific implementations and default to 1 (one) if
 
2227
    anything goes wrong.
 
2228
    """
 
2229
    global _cached_local_concurrency
 
2230
 
 
2231
    if _cached_local_concurrency is not None and use_cache:
 
2232
        return _cached_local_concurrency
 
2233
 
 
2234
    concurrency = os.environ.get('BZR_CONCURRENCY', None)
 
2235
    if concurrency is None:
 
2236
        try:
 
2237
            concurrency = _local_concurrency()
 
2238
        except (OSError, IOError):
 
2239
            pass
 
2240
    try:
 
2241
        concurrency = int(concurrency)
 
2242
    except (TypeError, ValueError):
 
2243
        concurrency = 1
 
2244
    if use_cache:
 
2245
        _cached_concurrency = concurrency
 
2246
    return concurrency
 
2247
 
 
2248
 
 
2249
class UnicodeOrBytesToBytesWriter(codecs.StreamWriter):
 
2250
    """A stream writer that doesn't decode str arguments."""
 
2251
 
 
2252
    def __init__(self, encode, stream, errors='strict'):
 
2253
        codecs.StreamWriter.__init__(self, stream, errors)
 
2254
        self.encode = encode
 
2255
 
 
2256
    def write(self, object):
 
2257
        if type(object) is str:
 
2258
            self.stream.write(object)
 
2259
        else:
 
2260
            data, _ = self.encode(object, self.errors)
 
2261
            self.stream.write(data)
 
2262
 
 
2263
if sys.platform == 'win32':
 
2264
    def open_file(filename, mode='r', bufsize=-1):
 
2265
        """This function is used to override the ``open`` builtin.
 
2266
        
 
2267
        But it uses O_NOINHERIT flag so the file handle is not inherited by
 
2268
        child processes.  Deleting or renaming a closed file opened with this
 
2269
        function is not blocking child processes.
 
2270
        """
 
2271
        writing = 'w' in mode
 
2272
        appending = 'a' in mode
 
2273
        updating = '+' in mode
 
2274
        binary = 'b' in mode
 
2275
 
 
2276
        flags = O_NOINHERIT
 
2277
        # see http://msdn.microsoft.com/en-us/library/yeby3zcb%28VS.71%29.aspx
 
2278
        # for flags for each modes.
 
2279
        if binary:
 
2280
            flags |= O_BINARY
 
2281
        else:
 
2282
            flags |= O_TEXT
 
2283
 
 
2284
        if writing:
 
2285
            if updating:
 
2286
                flags |= os.O_RDWR
 
2287
            else:
 
2288
                flags |= os.O_WRONLY
 
2289
            flags |= os.O_CREAT | os.O_TRUNC
 
2290
        elif appending:
 
2291
            if updating:
 
2292
                flags |= os.O_RDWR
 
2293
            else:
 
2294
                flags |= os.O_WRONLY
 
2295
            flags |= os.O_CREAT | os.O_APPEND
 
2296
        else: #reading
 
2297
            if updating:
 
2298
                flags |= os.O_RDWR
 
2299
            else:
 
2300
                flags |= os.O_RDONLY
 
2301
 
 
2302
        return os.fdopen(os.open(filename, flags), mode, bufsize)
 
2303
else:
 
2304
    open_file = open