← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/osutils.py

  • Committer: John Ferlito
  • Date: 2009-09-02 04:31:45 UTC
  • mto: (4665.7.1 serve-init)
  • mto: This revision was merged to the branch mainline in revision 4913.
  • Revision ID: johnf@inodes.org-20090902043145-gxdsfw03ilcwbyn5
Add a debian init script for bzr --serve

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/osutils.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2009 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
35
34
                    splitdrive as _nt_splitdrive,
36
35
                    )
37
36
import posixpath
38
 
import sha
39
37
import shutil
40
38
from shutil import (
41
39
    rmtree,
42
40
    )
 
41
import subprocess
43
42
import tempfile
44
43
from tempfile import (
45
44
    mkdtemp,
53
52
    )
54
53
""")
55
54
 
 
55
# sha and md5 modules are deprecated in python2.6 but hashlib is available as
 
56
# of 2.5
 
57
if sys.version_info < (2, 5):
 
58
    import md5 as _mod_md5
 
59
    md5 = _mod_md5.new
 
60
    import sha as _mod_sha
 
61
    sha = _mod_sha.new
 
62
else:
 
63
    from hashlib import (
 
64
        md5,
 
65
        sha1 as sha,
 
66
        )
 
67
 
56
68
 
57
69
import bzrlib
58
70
from bzrlib import symbol_versioning
59
 
from bzrlib.symbol_versioning import (
60
 
    deprecated_function,
61
 
    )
62
 
from bzrlib.trace import mutter
63
71
 
64
72
 
65
73
# On win32, O_BINARY is used to indicate the file should
70
78
O_BINARY = getattr(os, 'O_BINARY', 0)
71
79
 
72
80
 
 
81
def get_unicode_argv():
 
82
    try:
 
83
        user_encoding = get_user_encoding()
 
84
        return [a.decode(user_encoding) for a in sys.argv[1:]]
 
85
    except UnicodeDecodeError:
 
86
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
87
                                                            "encoding." % a))
 
88
 
 
89
 
73
90
def make_readonly(filename):
74
91
    """Make a filename read-only."""
75
92
    mod = os.lstat(filename).st_mode
90
107
 
91
108
    :param paths: A container (and hence not None) of paths.
92
109
    :return: A set of paths sufficient to include everything in paths via
93
 
        is_inside_any, drawn from the paths parameter.
 
110
        is_inside, drawn from the paths parameter.
94
111
    """
95
 
    search_paths = set()
96
 
    paths = set(paths)
97
 
    for path in paths:
98
 
        other_paths = paths.difference([path])
99
 
        if not is_inside_any(other_paths, path):
100
 
            # this is a top level path, we must check it.
101
 
            search_paths.add(path)
102
 
    return search_paths
 
112
    if len(paths) < 2:
 
113
        return set(paths)
 
114
 
 
115
    def sort_key(path):
 
116
        return path.split('/')
 
117
    sorted_paths = sorted(list(paths), key=sort_key)
 
118
 
 
119
    search_paths = [sorted_paths[0]]
 
120
    for path in sorted_paths[1:]:
 
121
        if not is_inside(search_paths[-1], path):
 
122
            # This path is unique, add it
 
123
            search_paths.append(path)
 
124
 
 
125
    return set(search_paths)
103
126
 
104
127
 
105
128
_QUOTE_RE = None
114
137
    global _QUOTE_RE
115
138
    if _QUOTE_RE is None:
116
139
        _QUOTE_RE = re.compile(r'([^a-zA-Z0-9.,:/\\_~-])')
117
 
        
 
140
 
118
141
    if _QUOTE_RE.search(f):
119
142
        return '"' + f + '"'
120
143
    else:
123
146
 
124
147
_directory_kind = 'directory'
125
148
 
126
 
_formats = {
127
 
    stat.S_IFDIR:_directory_kind,
128
 
    stat.S_IFCHR:'chardev',
129
 
    stat.S_IFBLK:'block',
130
 
    stat.S_IFREG:'file',
131
 
    stat.S_IFIFO:'fifo',
132
 
    stat.S_IFLNK:'symlink',
133
 
    stat.S_IFSOCK:'socket',
134
 
}
135
 
 
136
 
 
137
 
def file_kind_from_stat_mode(stat_mode, _formats=_formats, _unknown='unknown'):
138
 
    """Generate a file kind from a stat mode. This is used in walkdirs.
139
 
 
140
 
    Its performance is critical: Do not mutate without careful benchmarking.
141
 
    """
142
 
    try:
143
 
        return _formats[stat_mode & 0170000]
144
 
    except KeyError:
145
 
        return _unknown
146
 
 
147
 
 
148
 
def file_kind(f, _lstat=os.lstat, _mapper=file_kind_from_stat_mode):
149
 
    try:
150
 
        return _mapper(_lstat(f).st_mode)
151
 
    except OSError, e:
152
 
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
153
 
            raise errors.NoSuchFile(f)
154
 
        raise
155
 
 
156
 
 
157
149
def get_umask():
158
150
    """Return the current umask"""
159
151
    # Assume that people aren't messing with the umask while running
195
187
 
196
188
def fancy_rename(old, new, rename_func, unlink_func):
197
189
    """A fancy rename, when you don't have atomic rename.
198
 
    
 
190
 
199
191
    :param old: The old path, to rename from
200
192
    :param new: The new path, to rename to
201
193
    :param rename_func: The potentially non-atomic rename function
203
195
    """
204
196
 
205
197
    # sftp rename doesn't allow overwriting, so play tricks:
206
 
    import random
207
198
    base = os.path.basename(new)
208
199
    dirname = os.path.dirname(new)
209
200
    tmp_name = u'tmp.%s.%.9f.%d.%s' % (base, time.time(), os.getpid(), rand_chars(10))
316
307
        path = cwd + '\\' + path
317
308
    return _win32_fixdrive(_nt_normpath(path).replace('\\', '/'))
318
309
 
319
 
if win32utils.winver == 'Windows 98':
320
 
    _win32_abspath = _win98_abspath
321
 
 
322
310
 
323
311
def _win32_realpath(path):
324
312
    # Real _nt_realpath doesn't have a problem with a unicode cwd
345
333
    """We expect to be able to atomically replace 'new' with old.
346
334
 
347
335
    On win32, if new exists, it must be moved out of the way first,
348
 
    and then deleted. 
 
336
    and then deleted.
349
337
    """
350
338
    try:
351
339
        fancy_rename(old, new, rename_func=os.rename, unlink_func=os.unlink)
352
340
    except OSError, e:
353
341
        if e.errno in (errno.EPERM, errno.EACCES, errno.EBUSY, errno.EINVAL):
354
 
            # If we try to rename a non-existant file onto cwd, we get 
355
 
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT 
 
342
            # If we try to rename a non-existant file onto cwd, we get
 
343
            # EPERM or EACCES instead of ENOENT, this will raise ENOENT
356
344
            # if the old path doesn't exist, sometimes we get EACCES
357
345
            # On Linux, we seem to get EBUSY, on Mac we get EINVAL
358
346
            os.lstat(old)
383
371
 
384
372
 
385
373
if sys.platform == 'win32':
386
 
    abspath = _win32_abspath
 
374
    if win32utils.winver == 'Windows 98':
 
375
        abspath = _win98_abspath
 
376
    else:
 
377
        abspath = _win32_abspath
387
378
    realpath = _win32_realpath
388
379
    pathjoin = _win32_pathjoin
389
380
    normpath = _win32_normpath
409
400
    def rmtree(path, ignore_errors=False, onerror=_win32_delete_readonly):
410
401
        """Replacer for shutil.rmtree: could remove readonly dirs/files"""
411
402
        return shutil.rmtree(path, ignore_errors, onerror)
 
403
 
 
404
    f = win32utils.get_unicode_argv     # special function or None
 
405
    if f is not None:
 
406
        get_unicode_argv = f
 
407
 
412
408
elif sys.platform == 'darwin':
413
409
    getcwd = _mac_getcwd
414
410
 
418
414
 
419
415
    This attempts to check both sys.stdout and sys.stdin to see
420
416
    what encoding they are in, and if that fails it falls back to
421
 
    bzrlib.user_encoding.
 
417
    osutils.get_user_encoding().
422
418
    The problem is that on Windows, locale.getpreferredencoding()
423
419
    is not the same encoding as that used by the console:
424
420
    http://mail.python.org/pipermail/python-list/2003-May/162357.html
426
422
    On my standard US Windows XP, the preferred encoding is
427
423
    cp1252, but the console is cp437
428
424
    """
 
425
    from bzrlib.trace import mutter
429
426
    output_encoding = getattr(sys.stdout, 'encoding', None)
430
427
    if not output_encoding:
431
428
        input_encoding = getattr(sys.stdin, 'encoding', None)
432
429
        if not input_encoding:
433
 
            output_encoding = bzrlib.user_encoding
434
 
            mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
430
            output_encoding = get_user_encoding()
 
431
            mutter('encoding stdout as osutils.get_user_encoding() %r',
 
432
                   output_encoding)
435
433
        else:
436
434
            output_encoding = input_encoding
437
435
            mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
439
437
        mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
440
438
    if output_encoding == 'cp0':
441
439
        # invalid encoding (cp0 means 'no codepage' on Windows)
442
 
        output_encoding = bzrlib.user_encoding
 
440
        output_encoding = get_user_encoding()
443
441
        mutter('cp0 is invalid encoding.'
444
 
               ' encoding stdout as bzrlib.user_encoding %r', output_encoding)
 
442
               ' encoding stdout as osutils.get_user_encoding() %r',
 
443
               output_encoding)
445
444
    # check encoding
446
445
    try:
447
446
        codecs.lookup(output_encoding)
449
448
        sys.stderr.write('bzr: warning:'
450
449
                         ' unknown terminal encoding %s.\n'
451
450
                         '  Using encoding %s instead.\n'
452
 
                         % (output_encoding, bzrlib.user_encoding)
 
451
                         % (output_encoding, get_user_encoding())
453
452
                        )
454
 
        output_encoding = bzrlib.user_encoding
 
453
        output_encoding = get_user_encoding()
455
454
 
456
455
    return output_encoding
457
456
 
492
491
 
493
492
def is_inside(dir, fname):
494
493
    """True if fname is inside dir.
495
 
    
 
494
 
496
495
    The parameters should typically be passed to osutils.normpath first, so
497
496
    that . and .. and repeated slashes are eliminated, and the separators
498
497
    are canonical for the platform.
499
 
    
500
 
    The empty string as a dir name is taken as top-of-tree and matches 
 
498
 
 
499
    The empty string as a dir name is taken as top-of-tree and matches
501
500
    everything.
502
501
    """
503
 
    # XXX: Most callers of this can actually do something smarter by 
 
502
    # XXX: Most callers of this can actually do something smarter by
504
503
    # looking at the inventory
505
504
    if dir == fname:
506
505
        return True
507
 
    
 
506
 
508
507
    if dir == '':
509
508
        return True
510
509
 
530
529
    return False
531
530
 
532
531
 
533
 
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768):
 
532
def pumpfile(from_file, to_file, read_length=-1, buff_size=32768,
 
533
             report_activity=None, direction='read'):
534
534
    """Copy contents of one file to another.
535
535
 
536
536
    The read_length can either be -1 to read to end-of-file (EOF) or
539
539
    The buff_size represents the maximum size for each read operation
540
540
    performed on from_file.
541
541
 
 
542
    :param report_activity: Call this as bytes are read, see
 
543
        Transport._report_activity
 
544
    :param direction: Will be passed to report_activity
 
545
 
542
546
    :return: The number of bytes copied.
543
547
    """
544
548
    length = 0
552
556
            if not block:
553
557
                # EOF reached
554
558
                break
 
559
            if report_activity is not None:
 
560
                report_activity(len(block), direction)
555
561
            to_file.write(block)
556
562
 
557
563
            actual_bytes_read = len(block)
564
570
            if not block:
565
571
                # EOF reached
566
572
                break
 
573
            if report_activity is not None:
 
574
                report_activity(len(block), direction)
567
575
            to_file.write(block)
568
576
            length += len(block)
569
577
    return length
600
608
 
601
609
    The file cursor should be already at the start.
602
610
    """
603
 
    s = sha.new()
 
611
    s = sha()
604
612
    BUFSIZE = 128<<10
605
613
    while True:
606
614
        b = f.read(BUFSIZE)
610
618
    return s.hexdigest()
611
619
 
612
620
 
 
621
def size_sha_file(f):
 
622
    """Calculate the size and hexdigest of an open file.
 
623
 
 
624
    The file cursor should be already at the start and
 
625
    the caller is responsible for closing the file afterwards.
 
626
    """
 
627
    size = 0
 
628
    s = sha()
 
629
    BUFSIZE = 128<<10
 
630
    while True:
 
631
        b = f.read(BUFSIZE)
 
632
        if not b:
 
633
            break
 
634
        size += len(b)
 
635
        s.update(b)
 
636
    return size, s.hexdigest()
 
637
 
 
638
 
613
639
def sha_file_by_name(fname):
614
640
    """Calculate the SHA1 of a file by reading the full text"""
615
 
    s = sha.new()
 
641
    s = sha()
616
642
    f = os.open(fname, os.O_RDONLY | O_BINARY)
617
643
    try:
618
644
        while True:
624
650
        os.close(f)
625
651
 
626
652
 
627
 
def sha_strings(strings, _factory=sha.new):
 
653
def sha_strings(strings, _factory=sha):
628
654
    """Return the sha-1 of concatenation of strings"""
629
655
    s = _factory()
630
656
    map(s.update, strings)
631
657
    return s.hexdigest()
632
658
 
633
659
 
634
 
def sha_string(f, _factory=sha.new):
 
660
def sha_string(f, _factory=sha):
635
661
    return _factory(f).hexdigest()
636
662
 
637
663
 
638
664
def fingerprint_file(f):
639
665
    b = f.read()
640
666
    return {'size': len(b),
641
 
            'sha1': sha.new(b).hexdigest()}
 
667
            'sha1': sha(b).hexdigest()}
642
668
 
643
669
 
644
670
def compare_files(a, b):
661
687
    return offset.days * 86400 + offset.seconds
662
688
 
663
689
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
664
 
    
 
690
 
665
691
def format_date(t, offset=0, timezone='original', date_fmt=None,
666
692
                show_offset=True):
667
693
    """Return a formatted date string.
671
697
    :param timezone: How to display the time: 'utc', 'original' for the
672
698
         timezone specified by offset, or 'local' for the process's current
673
699
         timezone.
674
 
    :param show_offset: Whether to append the timezone.
675
 
    :param date_fmt: strftime format.
676
 
    """
 
700
    :param date_fmt: strftime format.
 
701
    :param show_offset: Whether to append the timezone.
 
702
    """
 
703
    (date_fmt, tt, offset_str) = \
 
704
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
705
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
 
706
    date_str = time.strftime(date_fmt, tt)
 
707
    return date_str + offset_str
 
708
 
 
709
def format_local_date(t, offset=0, timezone='original', date_fmt=None,
 
710
                      show_offset=True):
 
711
    """Return an unicode date string formatted according to the current locale.
 
712
 
 
713
    :param t: Seconds since the epoch.
 
714
    :param offset: Timezone offset in seconds east of utc.
 
715
    :param timezone: How to display the time: 'utc', 'original' for the
 
716
         timezone specified by offset, or 'local' for the process's current
 
717
         timezone.
 
718
    :param date_fmt: strftime format.
 
719
    :param show_offset: Whether to append the timezone.
 
720
    """
 
721
    (date_fmt, tt, offset_str) = \
 
722
               _format_date(t, offset, timezone, date_fmt, show_offset)
 
723
    date_str = time.strftime(date_fmt, tt)
 
724
    if not isinstance(date_str, unicode):
 
725
        date_str = date_str.decode(get_user_encoding(), 'replace')
 
726
    return date_str + offset_str
 
727
 
 
728
def _format_date(t, offset, timezone, date_fmt, show_offset):
677
729
    if timezone == 'utc':
678
730
        tt = time.gmtime(t)
679
731
        offset = 0
692
744
        offset_str = ' %+03d%02d' % (offset / 3600, (offset / 60) % 60)
693
745
    else:
694
746
        offset_str = ''
695
 
    # day of week depends on locale, so we do this ourself
696
 
    date_fmt = date_fmt.replace('%a', weekdays[tt[6]])
697
 
    return (time.strftime(date_fmt, tt) +  offset_str)
 
747
    return (date_fmt, tt, offset_str)
698
748
 
699
749
 
700
750
def compact_date(when):
701
751
    return time.strftime('%Y%m%d%H%M%S', time.gmtime(when))
702
 
    
 
752
 
703
753
 
704
754
def format_delta(delta):
705
755
    """Get a nice looking string for a time delta.
781
831
ALNUM = '0123456789abcdefghijklmnopqrstuvwxyz'
782
832
def rand_chars(num):
783
833
    """Return a random string of num alphanumeric characters
784
 
    
785
 
    The result only contains lowercase chars because it may be used on 
 
834
 
 
835
    The result only contains lowercase chars because it may be used on
786
836
    case-insensitive filesystems.
787
837
    """
788
838
    s = ''
810
860
            rps.append(f)
811
861
    return rps
812
862
 
 
863
 
813
864
def joinpath(p):
814
865
    for f in p:
815
866
        if (f == '..') or (f is None) or (f == ''):
817
868
    return pathjoin(*p)
818
869
 
819
870
 
 
871
def parent_directories(filename):
 
872
    """Return the list of parent directories, deepest first.
 
873
    
 
874
    For example, parent_directories("a/b/c") -> ["a/b", "a"].
 
875
    """
 
876
    parents = []
 
877
    parts = splitpath(dirname(filename))
 
878
    while parts:
 
879
        parents.append(joinpath(parts))
 
880
        parts.pop()
 
881
    return parents
 
882
 
 
883
 
 
884
try:
 
885
    from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
886
except ImportError:
 
887
    from bzrlib._chunks_to_lines_py import chunks_to_lines
 
888
 
 
889
 
820
890
def split_lines(s):
821
891
    """Split s into lines, but without removing the newline characters."""
 
892
    # Trivially convert a fulltext into a 'chunked' representation, and let
 
893
    # chunks_to_lines do the heavy lifting.
 
894
    if isinstance(s, str):
 
895
        # chunks_to_lines only supports 8-bit strings
 
896
        return chunks_to_lines([s])
 
897
    else:
 
898
        return _split_lines(s)
 
899
 
 
900
 
 
901
def _split_lines(s):
 
902
    """Split s into lines, but without removing the newline characters.
 
903
 
 
904
    This supports Unicode or plain string objects.
 
905
    """
822
906
    lines = s.split('\n')
823
907
    result = [line + '\n' for line in lines[:-1]]
824
908
    if lines[-1]:
843
927
        shutil.copyfile(src, dest)
844
928
 
845
929
 
846
 
# Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
847
 
# Forgiveness than Permission (EAFP) because:
848
 
# - root can damage a solaris file system by using unlink,
849
 
# - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
850
 
#   EACCES, OSX: EPERM) when invoked on a directory.
851
930
def delete_any(path):
852
 
    """Delete a file or directory."""
 
931
    """Delete a file, symlink or directory.  
 
932
    
 
933
    Will delete even if readonly.
 
934
    """
 
935
    try:
 
936
       _delete_file_or_dir(path)
 
937
    except (OSError, IOError), e:
 
938
        if e.errno in (errno.EPERM, errno.EACCES):
 
939
            # make writable and try again
 
940
            try:
 
941
                make_writable(path)
 
942
            except (OSError, IOError):
 
943
                pass
 
944
            _delete_file_or_dir(path)
 
945
        else:
 
946
            raise
 
947
 
 
948
 
 
949
def _delete_file_or_dir(path):
 
950
    # Look Before You Leap (LBYL) is appropriate here instead of Easier to Ask for
 
951
    # Forgiveness than Permission (EAFP) because:
 
952
    # - root can damage a solaris file system by using unlink,
 
953
    # - unlink raises different exceptions on different OSes (linux: EISDIR, win32:
 
954
    #   EACCES, OSX: EPERM) when invoked on a directory.
853
955
    if isdir(path): # Takes care of symlinks
854
956
        os.rmdir(path)
855
957
    else:
875
977
            and sys.platform not in ('cygwin', 'win32'))
876
978
 
877
979
 
 
980
def readlink(abspath):
 
981
    """Return a string representing the path to which the symbolic link points.
 
982
 
 
983
    :param abspath: The link absolute unicode path.
 
984
 
 
985
    This his guaranteed to return the symbolic link in unicode in all python
 
986
    versions.
 
987
    """
 
988
    link = abspath.encode(_fs_enc)
 
989
    target = os.readlink(link)
 
990
    target = target.decode(_fs_enc)
 
991
    return target
 
992
 
 
993
 
878
994
def contains_whitespace(s):
879
995
    """True if there are any whitespace characters in s."""
880
996
    # string.whitespace can include '\xa0' in certain locales, because it is
924
1040
 
925
1041
    s = []
926
1042
    head = rp
927
 
    while len(head) >= len(base):
 
1043
    while True:
 
1044
        if len(head) <= len(base) and head != base:
 
1045
            raise errors.PathNotChild(rp, base)
928
1046
        if head == base:
929
1047
            break
930
 
        head, tail = os.path.split(head)
 
1048
        head, tail = split(head)
931
1049
        if tail:
932
 
            s.insert(0, tail)
933
 
    else:
934
 
        raise errors.PathNotChild(rp, base)
 
1050
            s.append(tail)
935
1051
 
936
1052
    if s:
937
 
        return pathjoin(*s)
 
1053
        return pathjoin(*reversed(s))
938
1054
    else:
939
1055
        return ''
940
1056
 
941
1057
 
 
1058
def _cicp_canonical_relpath(base, path):
 
1059
    """Return the canonical path relative to base.
 
1060
 
 
1061
    Like relpath, but on case-insensitive-case-preserving file-systems, this
 
1062
    will return the relpath as stored on the file-system rather than in the
 
1063
    case specified in the input string, for all existing portions of the path.
 
1064
 
 
1065
    This will cause O(N) behaviour if called for every path in a tree; if you
 
1066
    have a number of paths to convert, you should use canonical_relpaths().
 
1067
    """
 
1068
    # TODO: it should be possible to optimize this for Windows by using the
 
1069
    # win32 API FindFiles function to look for the specified name - but using
 
1070
    # os.listdir() still gives us the correct, platform agnostic semantics in
 
1071
    # the short term.
 
1072
 
 
1073
    rel = relpath(base, path)
 
1074
    # '.' will have been turned into ''
 
1075
    if not rel:
 
1076
        return rel
 
1077
 
 
1078
    abs_base = abspath(base)
 
1079
    current = abs_base
 
1080
    _listdir = os.listdir
 
1081
 
 
1082
    # use an explicit iterator so we can easily consume the rest on early exit.
 
1083
    bit_iter = iter(rel.split('/'))
 
1084
    for bit in bit_iter:
 
1085
        lbit = bit.lower()
 
1086
        for look in _listdir(current):
 
1087
            if lbit == look.lower():
 
1088
                current = pathjoin(current, look)
 
1089
                break
 
1090
        else:
 
1091
            # got to the end, nothing matched, so we just return the
 
1092
            # non-existing bits as they were specified (the filename may be
 
1093
            # the target of a move, for example).
 
1094
            current = pathjoin(current, bit, *list(bit_iter))
 
1095
            break
 
1096
    return current[len(abs_base)+1:]
 
1097
 
 
1098
# XXX - TODO - we need better detection/integration of case-insensitive
 
1099
# file-systems; Linux often sees FAT32 devices (or NFS-mounted OSX
 
1100
# filesystems), for example, so could probably benefit from the same basic
 
1101
# support there.  For now though, only Windows and OSX get that support, and
 
1102
# they get it for *all* file-systems!
 
1103
if sys.platform in ('win32', 'darwin'):
 
1104
    canonical_relpath = _cicp_canonical_relpath
 
1105
else:
 
1106
    canonical_relpath = relpath
 
1107
 
 
1108
def canonical_relpaths(base, paths):
 
1109
    """Create an iterable to canonicalize a sequence of relative paths.
 
1110
 
 
1111
    The intent is for this implementation to use a cache, vastly speeding
 
1112
    up multiple transformations in the same directory.
 
1113
    """
 
1114
    # but for now, we haven't optimized...
 
1115
    return [canonical_relpath(base, p) for p in paths]
 
1116
 
942
1117
def safe_unicode(unicode_or_utf8_string):
943
1118
    """Coerce unicode_or_utf8_string into unicode.
944
1119
 
945
1120
    If it is unicode, it is returned.
946
 
    Otherwise it is decoded from utf-8. If a decoding error
947
 
    occurs, it is wrapped as a If the decoding fails, the exception is wrapped 
948
 
    as a BzrBadParameter exception.
 
1121
    Otherwise it is decoded from utf-8. If decoding fails, the exception is
 
1122
    wrapped in a BzrBadParameterNotUnicode exception.
949
1123
    """
950
1124
    if isinstance(unicode_or_utf8_string, unicode):
951
1125
        return unicode_or_utf8_string
1038
1212
 
1039
1213
    On platforms where the system normalizes filenames (Mac OSX),
1040
1214
    you can access a file by any path which will normalize correctly.
1041
 
    On platforms where the system does not normalize filenames 
 
1215
    On platforms where the system does not normalize filenames
1042
1216
    (Windows, Linux), you have to access a file by its exact path.
1043
1217
 
1044
 
    Internally, bzr only supports NFC normalization, since that is 
 
1218
    Internally, bzr only supports NFC normalization, since that is
1045
1219
    the standard for XML documents.
1046
1220
 
1047
1221
    So return the normalized path, and a flag indicating if the file
1118
1292
            del os.environ[env_variable]
1119
1293
    else:
1120
1294
        if isinstance(value, unicode):
1121
 
            value = value.encode(bzrlib.user_encoding)
 
1295
            value = value.encode(get_user_encoding())
1122
1296
        os.environ[env_variable] = value
1123
1297
    return orig_val
1124
1298
 
1127
1301
 
1128
1302
 
1129
1303
def check_legal_path(path):
1130
 
    """Check whether the supplied path is legal.  
 
1304
    """Check whether the supplied path is legal.
1131
1305
    This is only required on Windows, so we don't test on other platforms
1132
1306
    right now.
1133
1307
    """
1167
1341
 
1168
1342
def walkdirs(top, prefix=""):
1169
1343
    """Yield data about all the directories in a tree.
1170
 
    
 
1344
 
1171
1345
    This yields all the data about the contents of a directory at a time.
1172
1346
    After each directory has been yielded, if the caller has mutated the list
1173
1347
    to exclude some directories, they are then not descended into.
1174
 
    
 
1348
 
1175
1349
    The data yielded is of the form:
1176
1350
    ((directory-relpath, directory-path-from-top),
1177
1351
    [(relpath, basename, kind, lstat, path-from-top), ...]),
1178
1352
     - directory-relpath is the relative path of the directory being returned
1179
1353
       with respect to top. prefix is prepended to this.
1180
 
     - directory-path-from-root is the path including top for this directory. 
 
1354
     - directory-path-from-root is the path including top for this directory.
1181
1355
       It is suitable for use with os functions.
1182
1356
     - relpath is the relative path within the subtree being walked.
1183
1357
     - basename is the basename of the path
1185
1359
       present within the tree - but it may be recorded as versioned. See
1186
1360
       versioned_kind.
1187
1361
     - lstat is the stat data *if* the file was statted.
1188
 
     - planned, not implemented: 
 
1362
     - planned, not implemented:
1189
1363
       path_from_tree_root is the path from the root of the tree.
1190
1364
 
1191
 
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This 
 
1365
    :param prefix: Prefix the relpaths that are yielded with 'prefix'. This
1192
1366
        allows one to walk a subtree but get paths that are relative to a tree
1193
1367
        rooted higher up.
1194
1368
    :return: an iterator over the dirs.
1195
1369
    """
1196
1370
    #TODO there is a bit of a smell where the results of the directory-
1197
 
    # summary in this, and the path from the root, may not agree 
 
1371
    # summary in this, and the path from the root, may not agree
1198
1372
    # depending on top and prefix - i.e. ./foo and foo as a pair leads to
1199
1373
    # potentially confusing output. We should make this more robust - but
1200
1374
    # not at a speed cost. RBC 20060731
1201
1375
    _lstat = os.lstat
1202
1376
    _directory = _directory_kind
1203
1377
    _listdir = os.listdir
1204
 
    _kind_from_mode = _formats.get
 
1378
    _kind_from_mode = file_kind_from_stat_mode
1205
1379
    pending = [(safe_unicode(prefix), "", _directory, None, safe_unicode(top))]
1206
1380
    while pending:
1207
1381
        # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1223
1397
            for name in names:
1224
1398
                abspath = top_slash + name
1225
1399
                statvalue = _lstat(abspath)
1226
 
                kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1400
                kind = _kind_from_mode(statvalue.st_mode)
1227
1401
                append((relprefix + name, name, kind, statvalue, abspath))
1228
1402
        yield (relroot, top), dirblock
1229
1403
 
1231
1405
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1232
1406
 
1233
1407
 
1234
 
_real_walkdirs_utf8 = None
 
1408
class DirReader(object):
 
1409
    """An interface for reading directories."""
 
1410
 
 
1411
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1412
        """Converts top and prefix to a starting dir entry
 
1413
 
 
1414
        :param top: A utf8 path
 
1415
        :param prefix: An optional utf8 path to prefix output relative paths
 
1416
            with.
 
1417
        :return: A tuple starting with prefix, and ending with the native
 
1418
            encoding of top.
 
1419
        """
 
1420
        raise NotImplementedError(self.top_prefix_to_starting_dir)
 
1421
 
 
1422
    def read_dir(self, prefix, top):
 
1423
        """Read a specific dir.
 
1424
 
 
1425
        :param prefix: A utf8 prefix to be preprended to the path basenames.
 
1426
        :param top: A natively encoded path to read.
 
1427
        :return: A list of the directories contents. Each item contains:
 
1428
            (utf8_relpath, utf8_name, kind, lstatvalue, native_abspath)
 
1429
        """
 
1430
        raise NotImplementedError(self.read_dir)
 
1431
 
 
1432
 
 
1433
_selected_dir_reader = None
 
1434
 
1235
1435
 
1236
1436
def _walkdirs_utf8(top, prefix=""):
1237
1437
    """Yield data about all the directories in a tree.
1247
1447
        path-from-top might be unicode or utf8, but it is the correct path to
1248
1448
        pass to os functions to affect the file in question. (such as os.lstat)
1249
1449
    """
1250
 
    global _real_walkdirs_utf8
1251
 
    if _real_walkdirs_utf8 is None:
 
1450
    global _selected_dir_reader
 
1451
    if _selected_dir_reader is None:
1252
1452
        fs_encoding = _fs_enc.upper()
1253
 
        if win32utils.winver == 'Windows NT':
 
1453
        if sys.platform == "win32" and win32utils.winver == 'Windows NT':
1254
1454
            # Win98 doesn't have unicode apis like FindFirstFileW
1255
1455
            # TODO: We possibly could support Win98 by falling back to the
1256
1456
            #       original FindFirstFile, and using TCHAR instead of WCHAR,
1257
1457
            #       but that gets a bit tricky, and requires custom compiling
1258
1458
            #       for win98 anyway.
1259
1459
            try:
1260
 
                from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
1460
                from bzrlib._walkdirs_win32 import Win32ReadDir
 
1461
                _selected_dir_reader = Win32ReadDir()
1261
1462
            except ImportError:
1262
 
                _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
1263
 
            else:
1264
 
                _real_walkdirs_utf8 = _walkdirs_utf8_win32_find_file
1265
 
        elif fs_encoding not in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
 
1463
                pass
 
1464
        elif fs_encoding in ('UTF-8', 'US-ASCII', 'ANSI_X3.4-1968'):
1266
1465
            # ANSI_X3.4-1968 is a form of ASCII
1267
 
            _real_walkdirs_utf8 = _walkdirs_unicode_to_utf8
1268
 
        else:
1269
 
            _real_walkdirs_utf8 = _walkdirs_fs_utf8
1270
 
    return _real_walkdirs_utf8(top, prefix=prefix)
1271
 
 
1272
 
 
1273
 
def _walkdirs_fs_utf8(top, prefix=""):
1274
 
    """See _walkdirs_utf8.
1275
 
 
1276
 
    This sub-function is called when we know the filesystem is already in utf8
1277
 
    encoding. So we don't need to transcode filenames.
1278
 
    """
1279
 
    _lstat = os.lstat
1280
 
    _directory = _directory_kind
1281
 
    # Use C accelerated directory listing.
1282
 
    _listdir = _read_dir
1283
 
    _kind_from_mode = _formats.get
 
1466
            try:
 
1467
                from bzrlib._readdir_pyx import UTF8DirReader
 
1468
                _selected_dir_reader = UTF8DirReader()
 
1469
            except ImportError:
 
1470
                pass
 
1471
 
 
1472
    if _selected_dir_reader is None:
 
1473
        # Fallback to the python version
 
1474
        _selected_dir_reader = UnicodeDirReader()
1284
1475
 
1285
1476
    # 0 - relpath, 1- basename, 2- kind, 3- stat, 4-toppath
1286
1477
    # But we don't actually uses 1-3 in pending, so set them to None
1287
 
    pending = [(safe_utf8(prefix), None, None, None, safe_utf8(top))]
 
1478
    pending = [[_selected_dir_reader.top_prefix_to_starting_dir(top, prefix)]]
 
1479
    read_dir = _selected_dir_reader.read_dir
 
1480
    _directory = _directory_kind
1288
1481
    while pending:
1289
 
        relroot, _, _, _, top = pending.pop()
1290
 
        if relroot:
1291
 
            relprefix = relroot + '/'
1292
 
        else:
1293
 
            relprefix = ''
1294
 
        top_slash = top + '/'
1295
 
 
1296
 
        dirblock = []
1297
 
        append = dirblock.append
1298
 
        # read_dir supplies in should-stat order.
1299
 
        for _, name in sorted(_listdir(top)):
1300
 
            abspath = top_slash + name
1301
 
            statvalue = _lstat(abspath)
1302
 
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
1303
 
            append((relprefix + name, name, kind, statvalue, abspath))
1304
 
        dirblock.sort()
 
1482
        relroot, _, _, _, top = pending[-1].pop()
 
1483
        if not pending[-1]:
 
1484
            pending.pop()
 
1485
        dirblock = sorted(read_dir(relroot, top))
1305
1486
        yield (relroot, top), dirblock
1306
 
 
1307
1487
        # push the user specified dirs from dirblock
1308
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
1309
 
 
1310
 
 
1311
 
def _walkdirs_unicode_to_utf8(top, prefix=""):
1312
 
    """See _walkdirs_utf8
1313
 
 
1314
 
    Because Win32 has a Unicode api, all of the 'path-from-top' entries will be
1315
 
    Unicode paths.
1316
 
    This is currently the fallback code path when the filesystem encoding is
1317
 
    not UTF-8. It may be better to implement an alternative so that we can
1318
 
    safely handle paths that are not properly decodable in the current
1319
 
    encoding.
1320
 
    """
1321
 
    _utf8_encode = codecs.getencoder('utf8')
1322
 
    _lstat = os.lstat
1323
 
    _directory = _directory_kind
1324
 
    _listdir = os.listdir
1325
 
    _kind_from_mode = _formats.get
1326
 
 
1327
 
    pending = [(safe_utf8(prefix), None, None, None, safe_unicode(top))]
1328
 
    while pending:
1329
 
        relroot, _, _, _, top = pending.pop()
1330
 
        if relroot:
1331
 
            relprefix = relroot + '/'
 
1488
        next = [d for d in reversed(dirblock) if d[2] == _directory]
 
1489
        if next:
 
1490
            pending.append(next)
 
1491
 
 
1492
 
 
1493
class UnicodeDirReader(DirReader):
 
1494
    """A dir reader for non-utf8 file systems, which transcodes."""
 
1495
 
 
1496
    __slots__ = ['_utf8_encode']
 
1497
 
 
1498
    def __init__(self):
 
1499
        self._utf8_encode = codecs.getencoder('utf8')
 
1500
 
 
1501
    def top_prefix_to_starting_dir(self, top, prefix=""):
 
1502
        """See DirReader.top_prefix_to_starting_dir."""
 
1503
        return (safe_utf8(prefix), None, None, None, safe_unicode(top))
 
1504
 
 
1505
    def read_dir(self, prefix, top):
 
1506
        """Read a single directory from a non-utf8 file system.
 
1507
 
 
1508
        top, and the abspath element in the output are unicode, all other paths
 
1509
        are utf8. Local disk IO is done via unicode calls to listdir etc.
 
1510
 
 
1511
        This is currently the fallback code path when the filesystem encoding is
 
1512
        not UTF-8. It may be better to implement an alternative so that we can
 
1513
        safely handle paths that are not properly decodable in the current
 
1514
        encoding.
 
1515
 
 
1516
        See DirReader.read_dir for details.
 
1517
        """
 
1518
        _utf8_encode = self._utf8_encode
 
1519
        _lstat = os.lstat
 
1520
        _listdir = os.listdir
 
1521
        _kind_from_mode = file_kind_from_stat_mode
 
1522
 
 
1523
        if prefix:
 
1524
            relprefix = prefix + '/'
1332
1525
        else:
1333
1526
            relprefix = ''
1334
1527
        top_slash = top + u'/'
1336
1529
        dirblock = []
1337
1530
        append = dirblock.append
1338
1531
        for name in sorted(_listdir(top)):
1339
 
            name_utf8 = _utf8_encode(name)[0]
 
1532
            try:
 
1533
                name_utf8 = _utf8_encode(name)[0]
 
1534
            except UnicodeDecodeError:
 
1535
                raise errors.BadFilenameEncoding(
 
1536
                    _utf8_encode(relprefix)[0] + name, _fs_enc)
1340
1537
            abspath = top_slash + name
1341
1538
            statvalue = _lstat(abspath)
1342
 
            kind = _kind_from_mode(statvalue.st_mode & 0170000, 'unknown')
 
1539
            kind = _kind_from_mode(statvalue.st_mode)
1343
1540
            append((relprefix + name_utf8, name_utf8, kind, statvalue, abspath))
1344
 
        yield (relroot, top), dirblock
1345
 
 
1346
 
        # push the user specified dirs from dirblock
1347
 
        pending.extend(d for d in reversed(dirblock) if d[2] == _directory)
 
1541
        return dirblock
1348
1542
 
1349
1543
 
1350
1544
def copy_tree(from_path, to_path, handlers={}):
1351
1545
    """Copy all of the entries in from_path into to_path.
1352
1546
 
1353
 
    :param from_path: The base directory to copy. 
 
1547
    :param from_path: The base directory to copy.
1354
1548
    :param to_path: The target directory. If it does not exist, it will
1355
1549
        be created.
1356
1550
    :param handlers: A dictionary of functions, which takes a source and
1425
1619
        return _cached_user_encoding
1426
1620
 
1427
1621
    if sys.platform == 'darwin':
1428
 
        # work around egregious python 2.4 bug
 
1622
        # python locale.getpreferredencoding() always return
 
1623
        # 'mac-roman' on darwin. That's a lie.
1429
1624
        sys.platform = 'posix'
1430
1625
        try:
 
1626
            if os.environ.get('LANG', None) is None:
 
1627
                # If LANG is not set, we end up with 'ascii', which is bad
 
1628
                # ('mac-roman' is more than ascii), so we set a default which
 
1629
                # will give us UTF-8 (which appears to work in all cases on
 
1630
                # OSX). Users are still free to override LANG of course, as
 
1631
                # long as it give us something meaningful. This work-around
 
1632
                # *may* not be needed with python 3k and/or OSX 10.5, but will
 
1633
                # work with them too -- vila 20080908
 
1634
                os.environ['LANG'] = 'en_US.UTF-8'
1431
1635
            import locale
1432
1636
        finally:
1433
1637
            sys.platform = 'darwin'
1496
1700
    """
1497
1701
    b = ''
1498
1702
    while len(b) < bytes:
1499
 
        new = socket.recv(bytes - len(b))
 
1703
        new = until_no_eintr(socket.recv, bytes - len(b))
1500
1704
        if new == '':
1501
1705
            break # eof
1502
1706
        b += new
1503
1707
    return b
1504
1708
 
1505
1709
 
1506
 
def send_all(socket, bytes):
 
1710
def send_all(socket, bytes, report_activity=None):
1507
1711
    """Send all bytes on a socket.
1508
1712
 
1509
1713
    Regular socket.sendall() can give socket error 10053 on Windows.  This
1510
1714
    implementation sends no more than 64k at a time, which avoids this problem.
 
1715
 
 
1716
    :param report_activity: Call this as bytes are read, see
 
1717
        Transport._report_activity
1511
1718
    """
1512
1719
    chunk_size = 2**16
1513
1720
    for pos in xrange(0, len(bytes), chunk_size):
1514
 
        socket.sendall(bytes[pos:pos+chunk_size])
 
1721
        block = bytes[pos:pos+chunk_size]
 
1722
        if report_activity is not None:
 
1723
            report_activity(len(block), 'write')
 
1724
        until_no_eintr(socket.sendall, block)
1515
1725
 
1516
1726
 
1517
1727
def dereference_path(path):
1562
1772
    return open(filename, 'rU').read()
1563
1773
 
1564
1774
 
1565
 
try:
1566
 
    from bzrlib._readdir_pyx import read_dir as _read_dir
1567
 
except ImportError:
1568
 
    from bzrlib._readdir_py import read_dir as _read_dir
 
1775
def file_kind_from_stat_mode_thunk(mode):
 
1776
    global file_kind_from_stat_mode
 
1777
    if file_kind_from_stat_mode is file_kind_from_stat_mode_thunk:
 
1778
        try:
 
1779
            from bzrlib._readdir_pyx import UTF8DirReader
 
1780
            file_kind_from_stat_mode = UTF8DirReader().kind_from_mode
 
1781
        except ImportError:
 
1782
            from bzrlib._readdir_py import (
 
1783
                _kind_from_mode as file_kind_from_stat_mode
 
1784
                )
 
1785
    return file_kind_from_stat_mode(mode)
 
1786
file_kind_from_stat_mode = file_kind_from_stat_mode_thunk
 
1787
 
 
1788
 
 
1789
def file_kind(f, _lstat=os.lstat):
 
1790
    try:
 
1791
        return file_kind_from_stat_mode(_lstat(f).st_mode)
 
1792
    except OSError, e:
 
1793
        if getattr(e, 'errno', None) in (errno.ENOENT, errno.ENOTDIR):
 
1794
            raise errors.NoSuchFile(f)
 
1795
        raise
 
1796
 
 
1797
 
 
1798
def until_no_eintr(f, *a, **kw):
 
1799
    """Run f(*a, **kw), retrying if an EINTR error occurs."""
 
1800
    # Borrowed from Twisted's twisted.python.util.untilConcludes function.
 
1801
    while True:
 
1802
        try:
 
1803
            return f(*a, **kw)
 
1804
        except (IOError, OSError), e:
 
1805
            if e.errno == errno.EINTR:
 
1806
                continue
 
1807
            raise
 
1808
 
 
1809
def re_compile_checked(re_string, flags=0, where=""):
 
1810
    """Return a compiled re, or raise a sensible error.
 
1811
 
 
1812
    This should only be used when compiling user-supplied REs.
 
1813
 
 
1814
    :param re_string: Text form of regular expression.
 
1815
    :param flags: eg re.IGNORECASE
 
1816
    :param where: Message explaining to the user the context where
 
1817
        it occurred, eg 'log search filter'.
 
1818
    """
 
1819
    # from https://bugs.launchpad.net/bzr/+bug/251352
 
1820
    try:
 
1821
        re_obj = re.compile(re_string, flags)
 
1822
        re_obj.search("")
 
1823
        return re_obj
 
1824
    except re.error, e:
 
1825
        if where:
 
1826
            where = ' in ' + where
 
1827
        # despite the name 'error' is a type
 
1828
        raise errors.BzrCommandError('Invalid regular expression%s: %r: %s'
 
1829
            % (where, re_string, e))
 
1830
 
 
1831
 
 
1832
if sys.platform == "win32":
 
1833
    import msvcrt
 
1834
    def getchar():
 
1835
        return msvcrt.getch()
 
1836
else:
 
1837
    import tty
 
1838
    import termios
 
1839
    def getchar():
 
1840
        fd = sys.stdin.fileno()
 
1841
        settings = termios.tcgetattr(fd)
 
1842
        try:
 
1843
            tty.setraw(fd)
 
1844
            ch = sys.stdin.read(1)
 
1845
        finally:
 
1846
            termios.tcsetattr(fd, termios.TCSADRAIN, settings)
 
1847
        return ch
 
1848
 
 
1849
 
 
1850
if sys.platform == 'linux2':
 
1851
    def _local_concurrency():
 
1852
        concurrency = None
 
1853
        prefix = 'processor'
 
1854
        for line in file('/proc/cpuinfo', 'rb'):
 
1855
            if line.startswith(prefix):
 
1856
                concurrency = int(line[line.find(':')+1:]) + 1
 
1857
        return concurrency
 
1858
elif sys.platform == 'darwin':
 
1859
    def _local_concurrency():
 
1860
        return subprocess.Popen(['sysctl', '-n', 'hw.availcpu'],
 
1861
                                stdout=subprocess.PIPE).communicate()[0]
 
1862
elif sys.platform[0:7] == 'freebsd':
 
1863
    def _local_concurrency():
 
1864
        return subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
 
1865
                                stdout=subprocess.PIPE).communicate()[0]
 
1866
elif sys.platform == 'sunos5':
 
1867
    def _local_concurrency():
 
1868
        return subprocess.Popen(['psrinfo', '-p',],
 
1869
                                stdout=subprocess.PIPE).communicate()[0]
 
1870
elif sys.platform == "win32":
 
1871
    def _local_concurrency():
 
1872
        # This appears to return the number of cores.
 
1873
        return os.environ.get('NUMBER_OF_PROCESSORS')
 
1874
else:
 
1875
    def _local_concurrency():
 
1876
        # Who knows ?
 
1877
        return None
 
1878
 
 
1879
 
 
1880
_cached_local_concurrency = None
 
1881
 
 
1882
def local_concurrency(use_cache=True):
 
1883
    """Return how many processes can be run concurrently.
 
1884
 
 
1885
    Rely on platform specific implementations and default to 1 (one) if
 
1886
    anything goes wrong.
 
1887
    """
 
1888
    global _cached_local_concurrency
 
1889
    if _cached_local_concurrency is not None and use_cache:
 
1890
        return _cached_local_concurrency
 
1891
 
 
1892
    try:
 
1893
        concurrency = _local_concurrency()
 
1894
    except (OSError, IOError):
 
1895
        concurrency = None
 
1896
    try:
 
1897
        concurrency = int(concurrency)
 
1898
    except (TypeError, ValueError):
 
1899
        concurrency = 1
 
1900
    if use_cache:
 
1901
        _cached_concurrency = concurrency
 
1902
    return concurrency