/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/bzr/knit.py

  • Committer: Jelmer Vernooij
  • Date: 2019-11-02 23:19:18 UTC
  • mto: This revision was merged to the branch mainline in revision 7413.
  • Revision ID: jelmer@jelmer.uk-20191102231918-8umqkgb2j0lc262j
Fix support for reading from a dumb git server.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
51
51
 
52
52
"""
53
53
 
 
54
from __future__ import absolute_import
54
55
 
55
 
from cStringIO import StringIO
56
 
from itertools import izip
57
56
import operator
58
57
import os
59
 
import sys
60
58
 
61
 
from bzrlib.lazy_import import lazy_import
 
59
from ..lazy_import import lazy_import
62
60
lazy_import(globals(), """
63
 
from bzrlib import (
64
 
    annotate,
 
61
import patiencediff
 
62
import gzip
 
63
 
 
64
from breezy import (
65
65
    debug,
66
66
    diff,
67
 
    graph as _mod_graph,
68
 
    index as _mod_index,
69
 
    lru_cache,
70
 
    pack,
71
 
    progress,
72
67
    static_tuple,
73
68
    trace,
74
69
    tsort,
75
70
    tuned_gzip,
76
71
    ui,
77
72
    )
 
73
from breezy.bzr import (
 
74
    index as _mod_index,
 
75
    pack,
 
76
    )
 
77
 
 
78
from breezy.bzr import pack_repo
 
79
from breezy.i18n import gettext
78
80
""")
79
 
from bzrlib import (
 
81
from .. import (
 
82
    annotate,
80
83
    errors,
81
84
    osutils,
82
 
    patiencediff,
83
85
    )
84
 
from bzrlib.errors import (
85
 
    FileExists,
 
86
from ..errors import (
 
87
    InternalBzrError,
 
88
    InvalidRevisionId,
86
89
    NoSuchFile,
87
 
    KnitError,
88
 
    InvalidRevisionId,
89
 
    KnitCorrupt,
90
 
    KnitHeaderError,
91
90
    RevisionNotPresent,
92
 
    RevisionAlreadyPresent,
93
 
    SHA1KnitCorrupt,
94
91
    )
95
 
from bzrlib.osutils import (
 
92
from ..osutils import (
96
93
    contains_whitespace,
97
 
    contains_linebreaks,
98
94
    sha_string,
99
95
    sha_strings,
100
96
    split_lines,
101
97
    )
102
 
from bzrlib.versionedfile import (
 
98
from ..sixish import (
 
99
    BytesIO,
 
100
    range,
 
101
    viewitems,
 
102
    viewvalues,
 
103
    )
 
104
from ..bzr.versionedfile import (
 
105
    _KeyRefs,
103
106
    AbsentContentFactory,
104
107
    adapter_registry,
105
108
    ConstantMapper,
106
109
    ContentFactory,
107
 
    ChunkedContentFactory,
108
110
    sort_groupcompress,
109
 
    VersionedFile,
110
 
    VersionedFiles,
 
111
    VersionedFilesWithFallbacks,
111
112
    )
112
113
 
113
114
 
126
127
 
127
128
DATA_SUFFIX = '.knit'
128
129
INDEX_SUFFIX = '.kndx'
129
 
_STREAM_MIN_BUFFER_SIZE = 5*1024*1024
 
130
_STREAM_MIN_BUFFER_SIZE = 5 * 1024 * 1024
 
131
 
 
132
 
 
133
class KnitError(InternalBzrError):
 
134
 
 
135
    _fmt = "Knit error"
 
136
 
 
137
 
 
138
class KnitCorrupt(KnitError):
 
139
 
 
140
    _fmt = "Knit %(filename)s corrupt: %(how)s"
 
141
 
 
142
    def __init__(self, filename, how):
 
143
        KnitError.__init__(self)
 
144
        self.filename = filename
 
145
        self.how = how
 
146
 
 
147
 
 
148
class SHA1KnitCorrupt(KnitCorrupt):
 
149
 
 
150
    _fmt = ("Knit %(filename)s corrupt: sha-1 of reconstructed text does not "
 
151
            "match expected sha-1. key %(key)s expected sha %(expected)s actual "
 
152
            "sha %(actual)s")
 
153
 
 
154
    def __init__(self, filename, actual, expected, key, content):
 
155
        KnitError.__init__(self)
 
156
        self.filename = filename
 
157
        self.actual = actual
 
158
        self.expected = expected
 
159
        self.key = key
 
160
        self.content = content
 
161
 
 
162
 
 
163
class KnitDataStreamIncompatible(KnitError):
 
164
    # Not raised anymore, as we can convert data streams.  In future we may
 
165
    # need it again for more exotic cases, so we're keeping it around for now.
 
166
 
 
167
    _fmt = "Cannot insert knit data stream of format \"%(stream_format)s\" into knit of format \"%(target_format)s\"."
 
168
 
 
169
    def __init__(self, stream_format, target_format):
 
170
        self.stream_format = stream_format
 
171
        self.target_format = target_format
 
172
 
 
173
 
 
174
class KnitDataStreamUnknown(KnitError):
 
175
    # Indicates a data stream we don't know how to handle.
 
176
 
 
177
    _fmt = "Cannot parse knit data stream of format \"%(stream_format)s\"."
 
178
 
 
179
    def __init__(self, stream_format):
 
180
        self.stream_format = stream_format
 
181
 
 
182
 
 
183
class KnitHeaderError(KnitError):
 
184
 
 
185
    _fmt = 'Knit header error: %(badline)r unexpected for file "%(filename)s".'
 
186
 
 
187
    def __init__(self, badline, filename):
 
188
        KnitError.__init__(self)
 
189
        self.badline = badline
 
190
        self.filename = filename
 
191
 
 
192
 
 
193
class KnitIndexUnknownMethod(KnitError):
 
194
    """Raised when we don't understand the storage method.
 
195
 
 
196
    Currently only 'fulltext' and 'line-delta' are supported.
 
197
    """
 
198
 
 
199
    _fmt = ("Knit index %(filename)s does not have a known method"
 
200
            " in options: %(options)r")
 
201
 
 
202
    def __init__(self, filename, options):
 
203
        KnitError.__init__(self)
 
204
        self.filename = filename
 
205
        self.options = options
130
206
 
131
207
 
132
208
class KnitAdapter(object):
152
228
        rec, contents = \
153
229
            self._data._parse_record_unchecked(annotated_compressed_bytes)
154
230
        content = self._annotate_factory.parse_fulltext(contents, rec[1])
155
 
        size, bytes = self._data._record_to_data((rec[1],), rec[3], content.text())
 
231
        size, bytes = self._data._record_to_data(
 
232
            (rec[1],), rec[3], content.text())
156
233
        return bytes
157
234
 
158
235
 
164
241
        rec, contents = \
165
242
            self._data._parse_record_unchecked(annotated_compressed_bytes)
166
243
        delta = self._annotate_factory.parse_line_delta(contents, rec[1],
167
 
            plain=True)
 
244
                                                        plain=True)
168
245
        contents = self._plain_factory.lower_line_delta(delta)
169
246
        size, bytes = self._data._record_to_data((rec[1],), rec[3], contents)
170
247
        return bytes
178
255
        rec, contents = \
179
256
            self._data._parse_record_unchecked(annotated_compressed_bytes)
180
257
        content, delta = self._annotate_factory.parse_record(factory.key[-1],
181
 
            contents, factory._build_details, None)
182
 
        return ''.join(content.text())
 
258
                                                             contents, factory._build_details, None)
 
259
        return b''.join(content.text())
183
260
 
184
261
 
185
262
class DeltaAnnotatedToFullText(KnitAdapter):
190
267
        rec, contents = \
191
268
            self._data._parse_record_unchecked(annotated_compressed_bytes)
192
269
        delta = self._annotate_factory.parse_line_delta(contents, rec[1],
193
 
            plain=True)
 
270
                                                        plain=True)
194
271
        compression_parent = factory.parents[0]
195
 
        basis_entry = self._basis_vf.get_record_stream(
196
 
            [compression_parent], 'unordered', True).next()
 
272
        basis_entry = next(self._basis_vf.get_record_stream(
 
273
            [compression_parent], 'unordered', True))
197
274
        if basis_entry.storage_kind == 'absent':
198
275
            raise errors.RevisionNotPresent(compression_parent, self._basis_vf)
199
276
        basis_chunks = basis_entry.get_bytes_as('chunked')
203
280
        basis_content = PlainKnitContent(basis_lines, compression_parent)
204
281
        basis_content.apply_delta(delta, rec[1])
205
282
        basis_content._should_strip_eol = factory._build_details[1]
206
 
        return ''.join(basis_content.text())
 
283
        return b''.join(basis_content.text())
207
284
 
208
285
 
209
286
class FTPlainToFullText(KnitAdapter):
214
291
        rec, contents = \
215
292
            self._data._parse_record_unchecked(compressed_bytes)
216
293
        content, delta = self._plain_factory.parse_record(factory.key[-1],
217
 
            contents, factory._build_details, None)
218
 
        return ''.join(content.text())
 
294
                                                          contents, factory._build_details, None)
 
295
        return b''.join(content.text())
219
296
 
220
297
 
221
298
class DeltaPlainToFullText(KnitAdapter):
228
305
        delta = self._plain_factory.parse_line_delta(contents, rec[1])
229
306
        compression_parent = factory.parents[0]
230
307
        # XXX: string splitting overhead.
231
 
        basis_entry = self._basis_vf.get_record_stream(
232
 
            [compression_parent], 'unordered', True).next()
 
308
        basis_entry = next(self._basis_vf.get_record_stream(
 
309
            [compression_parent], 'unordered', True))
233
310
        if basis_entry.storage_kind == 'absent':
234
311
            raise errors.RevisionNotPresent(compression_parent, self._basis_vf)
235
312
        basis_chunks = basis_entry.get_bytes_as('chunked')
238
315
        # Manually apply the delta because we have one annotated content and
239
316
        # one plain.
240
317
        content, _ = self._plain_factory.parse_record(rec[1], contents,
241
 
            factory._build_details, basis_content)
242
 
        return ''.join(content.text())
 
318
                                                      factory._build_details, basis_content)
 
319
        return b''.join(content.text())
243
320
 
244
321
 
245
322
class KnitContentFactory(ContentFactory):
249
326
    """
250
327
 
251
328
    def __init__(self, key, parents, build_details, sha1, raw_record,
252
 
        annotated, knit=None, network_bytes=None):
 
329
                 annotated, knit=None, network_bytes=None):
253
330
        """Create a KnitContentFactory for key.
254
331
 
255
332
        :param key: The key.
283
360
    def _create_network_bytes(self):
284
361
        """Create a fully serialised network version for transmission."""
285
362
        # storage_kind, key, parents, Noeol, raw_record
286
 
        key_bytes = '\x00'.join(self.key)
 
363
        key_bytes = b'\x00'.join(self.key)
287
364
        if self.parents is None:
288
 
            parent_bytes = 'None:'
 
365
            parent_bytes = b'None:'
289
366
        else:
290
 
            parent_bytes = '\t'.join('\x00'.join(key) for key in self.parents)
 
367
            parent_bytes = b'\t'.join(b'\x00'.join(key)
 
368
                                      for key in self.parents)
291
369
        if self._build_details[1]:
292
 
            noeol = 'N'
 
370
            noeol = b'N'
293
371
        else:
294
 
            noeol = ' '
295
 
        network_bytes = "%s\n%s\n%s\n%s%s" % (self.storage_kind, key_bytes,
 
372
            noeol = b' '
 
373
        network_bytes = b"%s\n%s\n%s\n%s%s" % (
 
374
            self.storage_kind.encode('ascii'), key_bytes,
296
375
            parent_bytes, noeol, self._raw_record)
297
376
        self._network_bytes = network_bytes
298
377
 
301
380
            if self._network_bytes is None:
302
381
                self._create_network_bytes()
303
382
            return self._network_bytes
304
 
        if ('-ft-' in self.storage_kind and
305
 
            storage_kind in ('chunked', 'fulltext')):
 
383
        if ('-ft-' in self.storage_kind
 
384
                and storage_kind in ('chunked', 'fulltext')):
306
385
            adapter_key = (self.storage_kind, 'fulltext')
307
386
            adapter_factory = adapter_registry.get(adapter_key)
308
387
            adapter = adapter_factory(None)
319
398
            elif storage_kind == 'fulltext':
320
399
                return self._knit.get_text(self.key[0])
321
400
        raise errors.UnavailableRepresentation(self.key, storage_kind,
322
 
            self.storage_kind)
 
401
                                               self.storage_kind)
323
402
 
324
403
 
325
404
class LazyKnitContentFactory(ContentFactory):
355
434
            else:
356
435
                # all the keys etc are contained in the bytes returned in the
357
436
                # first record.
358
 
                return ''
 
437
                return b''
359
438
        if storage_kind in ('chunked', 'fulltext'):
360
439
            chunks = self._generator._get_one_work(self.key).text()
361
440
            if storage_kind == 'chunked':
362
441
                return chunks
363
442
            else:
364
 
                return ''.join(chunks)
 
443
                return b''.join(chunks)
365
444
        raise errors.UnavailableRepresentation(self.key, storage_kind,
366
 
            self.storage_kind)
 
445
                                               self.storage_kind)
367
446
 
368
447
 
369
448
def knit_delta_closure_to_records(storage_kind, bytes, line_end):
384
463
    :param bytes: The bytes of the record on the network.
385
464
    """
386
465
    start = line_end
387
 
    line_end = bytes.find('\n', start)
388
 
    key = tuple(bytes[start:line_end].split('\x00'))
 
466
    line_end = bytes.find(b'\n', start)
 
467
    key = tuple(bytes[start:line_end].split(b'\x00'))
389
468
    start = line_end + 1
390
 
    line_end = bytes.find('\n', start)
 
469
    line_end = bytes.find(b'\n', start)
391
470
    parent_line = bytes[start:line_end]
392
 
    if parent_line == 'None:':
 
471
    if parent_line == b'None:':
393
472
        parents = None
394
473
    else:
395
474
        parents = tuple(
396
 
            [tuple(segment.split('\x00')) for segment in parent_line.split('\t')
 
475
            [tuple(segment.split(b'\x00')) for segment in parent_line.split(b'\t')
397
476
             if segment])
398
477
    start = line_end + 1
399
 
    noeol = bytes[start] == 'N'
 
478
    noeol = bytes[start:start + 1] == b'N'
400
479
    if 'ft' in storage_kind:
401
480
        method = 'fulltext'
402
481
    else:
406
485
    raw_record = bytes[start:]
407
486
    annotated = 'annotated' in storage_kind
408
487
    return [KnitContentFactory(key, parents, build_details, None, raw_record,
409
 
        annotated, network_bytes=bytes)]
 
488
                               annotated, network_bytes=bytes)]
410
489
 
411
490
 
412
491
class KnitContent(object):
413
492
    """Content of a knit version to which deltas can be applied.
414
493
 
415
 
    This is always stored in memory as a list of lines with \n at the end,
 
494
    This is always stored in memory as a list of lines with \\n at the end,
416
495
    plus a flag saying if the final ending is really there or not, because that
417
496
    corresponds to the on-disk knit representation.
418
497
    """
450
529
            if n > 0:
451
530
                # knit deltas do not provide reliable info about whether the
452
531
                # last line of a file matches, due to eol handling.
453
 
                if source[s_pos + n -1] != target[t_pos + n -1]:
454
 
                    n-=1
 
532
                if source[s_pos + n - 1] != target[t_pos + n - 1]:
 
533
                    n -= 1
455
534
                if n > 0:
456
535
                    yield s_pos, t_pos, n
457
536
            t_pos += t_len + true_n
458
537
            s_pos = s_end
459
538
        n = target_len - t_pos
460
539
        if n > 0:
461
 
            if source[s_pos + n -1] != target[t_pos + n -1]:
462
 
                n-=1
 
540
            if source[s_pos + n - 1] != target[t_pos + n - 1]:
 
541
                n -= 1
463
542
            if n > 0:
464
543
                yield s_pos, t_pos, n
465
544
        yield s_pos + (target_len - t_pos), target_len, 0
470
549
 
471
550
    def __init__(self, lines):
472
551
        KnitContent.__init__(self)
473
 
        self._lines = lines
 
552
        self._lines = list(lines)
474
553
 
475
554
    def annotate(self):
476
555
        """Return a list of (origin, text) for each content line."""
477
556
        lines = self._lines[:]
478
557
        if self._should_strip_eol:
479
558
            origin, last_line = lines[-1]
480
 
            lines[-1] = (origin, last_line.rstrip('\n'))
 
559
            lines[-1] = (origin, last_line.rstrip(b'\n'))
481
560
        return lines
482
561
 
483
562
    def apply_delta(self, delta, new_version_id):
485
564
        offset = 0
486
565
        lines = self._lines
487
566
        for start, end, count, delta_lines in delta:
488
 
            lines[offset+start:offset+end] = delta_lines
 
567
            lines[offset + start:offset + end] = delta_lines
489
568
            offset = offset + (start - end) + count
490
569
 
491
570
    def text(self):
492
571
        try:
493
572
            lines = [text for origin, text in self._lines]
494
 
        except ValueError, e:
 
573
        except ValueError as e:
495
574
            # most commonly (only?) caused by the internal form of the knit
496
575
            # missing annotation information because of a bug - see thread
497
576
            # around 20071015
498
577
            raise KnitCorrupt(self,
499
 
                "line in annotated knit missing annotation information: %s"
500
 
                % (e,))
 
578
                              "line in annotated knit missing annotation information: %s"
 
579
                              % (e,))
501
580
        if self._should_strip_eol:
502
 
            lines[-1] = lines[-1].rstrip('\n')
 
581
            lines[-1] = lines[-1].rstrip(b'\n')
503
582
        return lines
504
583
 
505
584
    def copy(self):
506
 
        return AnnotatedKnitContent(self._lines[:])
 
585
        return AnnotatedKnitContent(self._lines)
507
586
 
508
587
 
509
588
class PlainKnitContent(KnitContent):
528
607
        offset = 0
529
608
        lines = self._lines
530
609
        for start, end, count, delta_lines in delta:
531
 
            lines[offset+start:offset+end] = delta_lines
 
610
            lines[offset + start:offset + end] = delta_lines
532
611
            offset = offset + (start - end) + count
533
612
        self._version_id = new_version_id
534
613
 
539
618
        lines = self._lines
540
619
        if self._should_strip_eol:
541
620
            lines = lines[:]
542
 
            lines[-1] = lines[-1].rstrip('\n')
 
621
            lines[-1] = lines[-1].rstrip(b'\n')
543
622
        return lines
544
623
 
545
624
 
598
677
        #       but the code itself doesn't really depend on that.
599
678
        #       Figure out a way to not require the overhead of turning the
600
679
        #       list back into tuples.
601
 
        lines = [tuple(line.split(' ', 1)) for line in content]
 
680
        lines = (tuple(line.split(b' ', 1)) for line in content)
602
681
        return AnnotatedKnitContent(lines)
603
682
 
604
 
    def parse_line_delta_iter(self, lines):
605
 
        return iter(self.parse_line_delta(lines))
606
 
 
607
683
    def parse_line_delta(self, lines, version_id, plain=False):
608
684
        """Convert a line based delta into internal representation.
609
685
 
620
696
        """
621
697
        result = []
622
698
        lines = iter(lines)
623
 
        next = lines.next
624
699
 
625
700
        cache = {}
 
701
 
626
702
        def cache_and_return(line):
627
 
            origin, text = line.split(' ', 1)
 
703
            origin, text = line.split(b' ', 1)
628
704
            return cache.setdefault(origin, origin), text
629
705
 
630
706
        # walk through the lines parsing.
632
708
        # loop to minimise any performance impact
633
709
        if plain:
634
710
            for header in lines:
635
 
                start, end, count = [int(n) for n in header.split(',')]
636
 
                contents = [next().split(' ', 1)[1] for i in xrange(count)]
 
711
                start, end, count = [int(n) for n in header.split(b',')]
 
712
                contents = [next(lines).split(b' ', 1)[1]
 
713
                            for _ in range(count)]
637
714
                result.append((start, end, count, contents))
638
715
        else:
639
716
            for header in lines:
640
 
                start, end, count = [int(n) for n in header.split(',')]
641
 
                contents = [tuple(next().split(' ', 1)) for i in xrange(count)]
 
717
                start, end, count = [int(n) for n in header.split(b',')]
 
718
                contents = [tuple(next(lines).split(b' ', 1))
 
719
                            for _ in range(count)]
642
720
                result.append((start, end, count, contents))
643
721
        return result
644
722
 
645
723
    def get_fulltext_content(self, lines):
646
724
        """Extract just the content lines from a fulltext."""
647
 
        return (line.split(' ', 1)[1] for line in lines)
 
725
        return (line.split(b' ', 1)[1] for line in lines)
648
726
 
649
727
    def get_linedelta_content(self, lines):
650
728
        """Extract just the content from a line delta.
653
731
        Only the actual content lines.
654
732
        """
655
733
        lines = iter(lines)
656
 
        next = lines.next
657
734
        for header in lines:
658
 
            header = header.split(',')
 
735
            header = header.split(b',')
659
736
            count = int(header[2])
660
 
            for i in xrange(count):
661
 
                origin, text = next().split(' ', 1)
 
737
            for _ in range(count):
 
738
                origin, text = next(lines).split(b' ', 1)
662
739
                yield text
663
740
 
664
741
    def lower_fulltext(self, content):
666
743
 
667
744
        see parse_fulltext which this inverts.
668
745
        """
669
 
        return ['%s %s' % (o, t) for o, t in content._lines]
 
746
        return [b'%s %s' % (o, t) for o, t in content._lines]
670
747
 
671
748
    def lower_line_delta(self, delta):
672
749
        """convert a delta into a serializable form.
677
754
        #       the origin is a valid utf-8 line, eventually we could remove it
678
755
        out = []
679
756
        for start, end, c, lines in delta:
680
 
            out.append('%d,%d,%d\n' % (start, end, c))
681
 
            out.extend(origin + ' ' + text
 
757
            out.append(b'%d,%d,%d\n' % (start, end, c))
 
758
            out.extend(origin + b' ' + text
682
759
                       for origin, text in lines)
683
760
        return out
684
761
 
686
763
        content = knit._get_content(key)
687
764
        # adjust for the fact that serialised annotations are only key suffixes
688
765
        # for this factory.
689
 
        if type(key) is tuple:
 
766
        if isinstance(key, tuple):
690
767
            prefix = key[:-1]
691
768
            origins = content.annotate()
692
769
            result = []
721
798
        while cur < num_lines:
722
799
            header = lines[cur]
723
800
            cur += 1
724
 
            start, end, c = [int(n) for n in header.split(',')]
725
 
            yield start, end, c, lines[cur:cur+c]
 
801
            start, end, c = [int(n) for n in header.split(b',')]
 
802
            yield start, end, c, lines[cur:cur + c]
726
803
            cur += c
727
804
 
728
805
    def parse_line_delta(self, lines, version_id):
739
816
        Only the actual content lines.
740
817
        """
741
818
        lines = iter(lines)
742
 
        next = lines.next
743
819
        for header in lines:
744
 
            header = header.split(',')
 
820
            header = header.split(b',')
745
821
            count = int(header[2])
746
 
            for i in xrange(count):
747
 
                yield next()
 
822
            for _ in range(count):
 
823
                yield next(lines)
748
824
 
749
825
    def lower_fulltext(self, content):
750
826
        return content.text()
752
828
    def lower_line_delta(self, delta):
753
829
        out = []
754
830
        for start, end, c, lines in delta:
755
 
            out.append('%d,%d,%d\n' % (start, end, c))
 
831
            out.append(b'%d,%d,%d\n' % (start, end, c))
756
832
            out.extend(lines)
757
833
        return out
758
834
 
761
837
        return annotator.annotate_flat(key)
762
838
 
763
839
 
764
 
 
765
840
def make_file_factory(annotated, mapper):
766
841
    """Create a factory for creating a file based KnitVersionedFiles.
767
842
 
772
847
    :param mapper: The mapper from keys to paths.
773
848
    """
774
849
    def factory(transport):
775
 
        index = _KndxIndex(transport, mapper, lambda:None, lambda:True, lambda:True)
 
850
        index = _KndxIndex(transport, mapper, lambda: None,
 
851
                           lambda: True, lambda: True)
776
852
        access = _KnitKeyAccess(transport, mapper)
777
853
        return KnitVersionedFiles(index, access, annotated=annotated)
778
854
    return factory
799
875
        else:
800
876
            max_delta_chain = 0
801
877
        graph_index = _mod_index.InMemoryGraphIndex(reference_lists=ref_length,
802
 
            key_elements=keylength)
 
878
                                                    key_elements=keylength)
803
879
        stream = transport.open_write_stream('newpack')
804
880
        writer = pack.ContainerWriter(stream.write)
805
881
        writer.begin()
806
 
        index = _KnitGraphIndex(graph_index, lambda:True, parents=parents,
807
 
            deltas=delta, add_callback=graph_index.add_nodes)
808
 
        access = _DirectPackAccess({})
 
882
        index = _KnitGraphIndex(graph_index, lambda: True, parents=parents,
 
883
                                deltas=delta, add_callback=graph_index.add_nodes)
 
884
        access = pack_repo._DirectPackAccess({})
809
885
        access.set_writer(writer, graph_index, (transport, 'newpack'))
810
886
        result = KnitVersionedFiles(index, access,
811
 
            max_delta_chain=max_delta_chain)
 
887
                                    max_delta_chain=max_delta_chain)
812
888
        result.stream = stream
813
889
        result.writer = writer
814
890
        return result
845
921
            if compression_parent not in all_build_index_memos:
846
922
                next_keys.add(compression_parent)
847
923
        build_keys = next_keys
848
 
    return sum([index_memo[2] for index_memo
849
 
                in all_build_index_memos.itervalues()])
850
 
 
851
 
 
852
 
class KnitVersionedFiles(VersionedFiles):
 
924
    return sum(index_memo[2]
 
925
               for index_memo in viewvalues(all_build_index_memos))
 
926
 
 
927
 
 
928
class KnitVersionedFiles(VersionedFilesWithFallbacks):
853
929
    """Storage for many versioned files using knit compression.
854
930
 
855
931
    Backend storage is managed by indices and data objects.
873
949
            stored during insertion.
874
950
        :param reload_func: An function that can be called if we think we need
875
951
            to reload the pack listing and try again. See
876
 
            'bzrlib.repofmt.pack_repo.AggregateIndex' for the signature.
 
952
            'breezy.bzr.pack_repo.AggregateIndex' for the signature.
877
953
        """
878
954
        self._index = index
879
955
        self._access = data_access
882
958
            self._factory = KnitAnnotateFactory()
883
959
        else:
884
960
            self._factory = KnitPlainFactory()
885
 
        self._fallback_vfs = []
 
961
        self._immediate_fallback_vfs = []
886
962
        self._reload_func = reload_func
887
963
 
888
964
    def __repr__(self):
891
967
            self._index,
892
968
            self._access)
893
969
 
 
970
    def without_fallbacks(self):
 
971
        """Return a clone of this object without any fallbacks configured."""
 
972
        return KnitVersionedFiles(self._index, self._access,
 
973
                                  self._max_delta_chain, self._factory.annotated,
 
974
                                  self._reload_func)
 
975
 
894
976
    def add_fallback_versioned_files(self, a_versioned_files):
895
977
        """Add a source of texts for texts not present in this knit.
896
978
 
897
979
        :param a_versioned_files: A VersionedFiles object.
898
980
        """
899
 
        self._fallback_vfs.append(a_versioned_files)
 
981
        self._immediate_fallback_vfs.append(a_versioned_files)
900
982
 
901
983
    def add_lines(self, key, parents, lines, parent_texts=None,
902
 
        left_matching_blocks=None, nostore_sha=None, random_id=False,
903
 
        check_content=True):
 
984
                  left_matching_blocks=None, nostore_sha=None, random_id=False,
 
985
                  check_content=True):
904
986
        """See VersionedFiles.add_lines()."""
905
987
        self._index._check_write_ok()
906
988
        self._check_add(key, lines, random_id, check_content)
909
991
            # indexes can't directly store that, so we give them
910
992
            # an empty tuple instead.
911
993
            parents = ()
912
 
        line_bytes = ''.join(lines)
 
994
        line_bytes = b''.join(lines)
913
995
        return self._add(key, lines, parents,
914
 
            parent_texts, left_matching_blocks, nostore_sha, random_id,
915
 
            line_bytes=line_bytes)
 
996
                         parent_texts, left_matching_blocks, nostore_sha, random_id,
 
997
                         line_bytes=line_bytes)
916
998
 
917
 
    def _add_text(self, key, parents, text, nostore_sha=None, random_id=False):
918
 
        """See VersionedFiles._add_text()."""
 
999
    def add_chunks(self, key, parents, chunk_iter, parent_texts=None,
 
1000
                   left_matching_blocks=None, nostore_sha=None, random_id=False):
 
1001
        """See VersionedFiles.add_chunks()."""
919
1002
        self._index._check_write_ok()
920
1003
        self._check_add(key, None, random_id, check_content=False)
921
 
        if text.__class__ is not str:
922
 
            raise errors.BzrBadParameterUnicode("text")
923
1004
        if parents is None:
924
1005
            # The caller might pass None if there is no graph data, but kndx
925
1006
            # indexes can't directly store that, so we give them
926
1007
            # an empty tuple instead.
927
1008
            parents = ()
 
1009
        line_bytes = b''.join(chunk_iter)
928
1010
        return self._add(key, None, parents,
929
 
            None, None, nostore_sha, random_id,
930
 
            line_bytes=text)
 
1011
                         parent_texts, left_matching_blocks, nostore_sha, random_id,
 
1012
                         line_bytes=line_bytes)
931
1013
 
932
1014
    def _add(self, key, lines, parents, parent_texts,
933
 
        left_matching_blocks, nostore_sha, random_id,
934
 
        line_bytes):
 
1015
             left_matching_blocks, nostore_sha, random_id,
 
1016
             line_bytes):
935
1017
        """Add a set of lines on top of version specified by parents.
936
1018
 
937
1019
        Any versions not present will be converted into ghosts.
963
1045
                present_parents.append(parent)
964
1046
 
965
1047
        # Currently we can only compress against the left most present parent.
966
 
        if (len(present_parents) == 0 or
967
 
            present_parents[0] != parents[0]):
 
1048
        if (len(present_parents) == 0
 
1049
                or present_parents[0] != parents[0]):
968
1050
            delta = False
969
1051
        else:
970
1052
            # To speed the extract of texts the delta chain is limited
978
1060
        # Note: line_bytes is not modified to add a newline, that is tracked
979
1061
        #       via the no_eol flag. 'lines' *is* modified, because that is the
980
1062
        #       general values needed by the Content code.
981
 
        if line_bytes and line_bytes[-1] != '\n':
982
 
            options.append('no-eol')
 
1063
        if line_bytes and not line_bytes.endswith(b'\n'):
 
1064
            options.append(b'no-eol')
983
1065
            no_eol = True
984
1066
            # Copy the existing list, or create a new one
985
1067
            if lines is None:
987
1069
            else:
988
1070
                lines = lines[:]
989
1071
            # Replace the last line with one that ends in a final newline
990
 
            lines[-1] = lines[-1] + '\n'
 
1072
            lines[-1] = lines[-1] + b'\n'
991
1073
        if lines is None:
992
1074
            lines = osutils.split_lines(line_bytes)
993
1075
 
994
1076
        for element in key[:-1]:
995
 
            if type(element) is not str:
996
 
                raise TypeError("key contains non-strings: %r" % (key,))
 
1077
            if not isinstance(element, bytes):
 
1078
                raise TypeError("key contains non-bytestrings: %r" % (key,))
997
1079
        if key[-1] is None:
998
 
            key = key[:-1] + ('sha1:' + digest,)
999
 
        elif type(key[-1]) is not str:
1000
 
                raise TypeError("key contains non-strings: %r" % (key,))
 
1080
            key = key[:-1] + (b'sha1:' + digest,)
 
1081
        elif not isinstance(key[-1], bytes):
 
1082
            raise TypeError("key contains non-bytestrings: %r" % (key,))
1001
1083
        # Knit hunks are still last-element only
1002
1084
        version_id = key[-1]
1003
1085
        content = self._factory.make(lines, version_id)
1008
1090
        if delta or (self._factory.annotated and len(present_parents) > 0):
1009
1091
            # Merge annotations from parent texts if needed.
1010
1092
            delta_hunks = self._merge_annotations(content, present_parents,
1011
 
                parent_texts, delta, self._factory.annotated,
1012
 
                left_matching_blocks)
 
1093
                                                  parent_texts, delta, self._factory.annotated,
 
1094
                                                  left_matching_blocks)
1013
1095
 
1014
1096
        if delta:
1015
 
            options.append('line-delta')
 
1097
            options.append(b'line-delta')
1016
1098
            store_lines = self._factory.lower_line_delta(delta_hunks)
1017
 
            size, bytes = self._record_to_data(key, digest,
1018
 
                store_lines)
 
1099
            size, data = self._record_to_data(key, digest,
 
1100
                                              store_lines)
1019
1101
        else:
1020
 
            options.append('fulltext')
 
1102
            options.append(b'fulltext')
1021
1103
            # isinstance is slower and we have no hierarchy.
1022
1104
            if self._factory.__class__ is KnitPlainFactory:
1023
1105
                # Use the already joined bytes saving iteration time in
1024
1106
                # _record_to_data.
1025
1107
                dense_lines = [line_bytes]
1026
1108
                if no_eol:
1027
 
                    dense_lines.append('\n')
1028
 
                size, bytes = self._record_to_data(key, digest,
1029
 
                    lines, dense_lines)
 
1109
                    dense_lines.append(b'\n')
 
1110
                size, data = self._record_to_data(key, digest,
 
1111
                                                  lines, dense_lines)
1030
1112
            else:
1031
1113
                # get mixed annotation + content and feed it into the
1032
1114
                # serialiser.
1033
1115
                store_lines = self._factory.lower_fulltext(content)
1034
 
                size, bytes = self._record_to_data(key, digest,
1035
 
                    store_lines)
 
1116
                size, data = self._record_to_data(key, digest,
 
1117
                                                  store_lines)
1036
1118
 
1037
 
        access_memo = self._access.add_raw_records([(key, size)], bytes)[0]
 
1119
        access_memo = self._access.add_raw_records([(key, size)], data)[0]
1038
1120
        self._index.add_records(
1039
1121
            ((key, options, access_memo, parents),),
1040
1122
            random_id=random_id)
1066
1148
            if self._index.get_method(key) != 'fulltext':
1067
1149
                compression_parent = parent_map[key][0]
1068
1150
                if compression_parent not in parent_map:
1069
 
                    raise errors.KnitCorrupt(self,
1070
 
                        "Missing basis parent %s for %s" % (
1071
 
                        compression_parent, key))
1072
 
        for fallback_vfs in self._fallback_vfs:
 
1151
                    raise KnitCorrupt(self,
 
1152
                                      "Missing basis parent %s for %s" % (
 
1153
                                          compression_parent, key))
 
1154
        for fallback_vfs in self._immediate_fallback_vfs:
1073
1155
            fallback_vfs.check()
1074
1156
 
1075
1157
    def _check_add(self, key, lines, random_id, check_content):
1076
1158
        """check that version_id and lines are safe to add."""
 
1159
        if not all(isinstance(x, bytes) or x is None for x in key):
 
1160
            raise TypeError(key)
1077
1161
        version_id = key[-1]
1078
1162
        if version_id is not None:
1079
1163
            if contains_whitespace(version_id):
1099
1183
        """
1100
1184
        if rec[1] != version_id:
1101
1185
            raise KnitCorrupt(self,
1102
 
                'unexpected version, wanted %r, got %r' % (version_id, rec[1]))
 
1186
                              'unexpected version, wanted %r, got %r' % (version_id, rec[1]))
1103
1187
 
1104
1188
    def _check_should_delta(self, parent):
1105
1189
        """Iterate back through the parent listing, looking for a fulltext.
1114
1198
        """
1115
1199
        delta_size = 0
1116
1200
        fulltext_size = None
1117
 
        for count in xrange(self._max_delta_chain):
 
1201
        for count in range(self._max_delta_chain):
1118
1202
            try:
1119
1203
                # Note that this only looks in the index of this particular
1120
1204
                # KnitVersionedFiles, not in the fallbacks.  This ensures that
1122
1206
                # boundaries.
1123
1207
                build_details = self._index.get_build_details([parent])
1124
1208
                parent_details = build_details[parent]
1125
 
            except (RevisionNotPresent, KeyError), e:
 
1209
            except (RevisionNotPresent, KeyError) as e:
1126
1210
                # Some basis is not locally present: always fulltext
1127
1211
                return False
1128
1212
            index_memo, compression_parent, _, _ = parent_details
1153
1237
 
1154
1238
        A dict of key to (record_details, index_memo, next, parents) is
1155
1239
        returned.
1156
 
        method is the way referenced data should be applied.
1157
 
        index_memo is the handle to pass to the data access to actually get the
1158
 
            data
1159
 
        next is the build-parent of the version, or None for fulltexts.
1160
 
        parents is the version_ids of the parents of this version
1161
 
 
1162
 
        :param allow_missing: If True do not raise an error on a missing component,
1163
 
            just ignore it.
 
1240
 
 
1241
        * method is the way referenced data should be applied.
 
1242
        * index_memo is the handle to pass to the data access to actually get
 
1243
          the data
 
1244
        * next is the build-parent of the version, or None for fulltexts.
 
1245
        * parents is the version_ids of the parents of this version
 
1246
 
 
1247
        :param allow_missing: If True do not raise an error on a missing
 
1248
            component, just ignore it.
1164
1249
        """
1165
1250
        component_data = {}
1166
1251
        pending_components = keys
1168
1253
            build_details = self._index.get_build_details(pending_components)
1169
1254
            current_components = set(pending_components)
1170
1255
            pending_components = set()
1171
 
            for key, details in build_details.iteritems():
 
1256
            for key, details in viewitems(build_details):
1172
1257
                (index_memo, compression_parent, parents,
1173
1258
                 record_details) = details
1174
 
                method = record_details[0]
1175
1259
                if compression_parent is not None:
1176
1260
                    pending_components.add(compression_parent)
1177
 
                component_data[key] = self._build_details_to_components(details)
 
1261
                component_data[key] = self._build_details_to_components(
 
1262
                    details)
1178
1263
            missing = current_components.difference(build_details)
1179
1264
            if missing and not allow_missing:
1180
1265
                raise errors.RevisionNotPresent(missing.pop(), self)
1192
1277
        generator = _VFContentMapGenerator(self, [key])
1193
1278
        return generator._get_content(key)
1194
1279
 
1195
 
    def get_known_graph_ancestry(self, keys):
1196
 
        """Get a KnownGraph instance with the ancestry of keys."""
1197
 
        parent_map, missing_keys = self._index.find_ancestry(keys)
1198
 
        for fallback in self._fallback_vfs:
1199
 
            if not missing_keys:
1200
 
                break
1201
 
            (f_parent_map, f_missing_keys) = fallback._index.find_ancestry(
1202
 
                                                missing_keys)
1203
 
            parent_map.update(f_parent_map)
1204
 
            missing_keys = f_missing_keys
1205
 
        kg = _mod_graph.KnownGraph(parent_map)
1206
 
        return kg
1207
 
 
1208
1280
    def get_parent_map(self, keys):
1209
1281
        """Get a map of the graph parents of keys.
1210
1282
 
1225
1297
            and so on.
1226
1298
        """
1227
1299
        result = {}
1228
 
        sources = [self._index] + self._fallback_vfs
 
1300
        sources = [self._index] + self._immediate_fallback_vfs
1229
1301
        source_results = []
1230
1302
        missing = set(keys)
1231
1303
        for source in sources:
1241
1313
        """Produce a dictionary of knit records.
1242
1314
 
1243
1315
        :return: {key:(record, record_details, digest, next)}
1244
 
            record
1245
 
                data returned from read_records (a KnitContentobject)
1246
 
            record_details
1247
 
                opaque information to pass to parse_record
1248
 
            digest
1249
 
                SHA1 digest of the full text after all steps are done
1250
 
            next
1251
 
                build-parent of the version, i.e. the leftmost ancestor.
 
1316
 
 
1317
            * record: data returned from read_records (a KnitContentobject)
 
1318
            * record_details: opaque information to pass to parse_record
 
1319
            * digest: SHA1 digest of the full text after all steps are done
 
1320
            * next: build-parent of the version, i.e. the leftmost ancestor.
1252
1321
                Will be None if the record is not a delta.
 
1322
 
1253
1323
        :param keys: The keys to build a map for
1254
1324
        :param allow_missing: If some records are missing, rather than
1255
1325
            error, just return the data that could be generated.
1256
1326
        """
1257
1327
        raw_map = self._get_record_map_unparsed(keys,
1258
 
            allow_missing=allow_missing)
 
1328
                                                allow_missing=allow_missing)
1259
1329
        return self._raw_map_to_record_map(raw_map)
1260
1330
 
1261
1331
    def _raw_map_to_record_map(self, raw_map):
1286
1356
        while True:
1287
1357
            try:
1288
1358
                position_map = self._get_components_positions(keys,
1289
 
                    allow_missing=allow_missing)
 
1359
                                                              allow_missing=allow_missing)
1290
1360
                # key = component_id, r = record_details, i_m = index_memo,
1291
1361
                # n = next
1292
1362
                records = [(key, i_m) for key, (r, i_m, n)
1293
 
                                       in position_map.iteritems()]
 
1363
                           in viewitems(position_map)]
1294
1364
                # Sort by the index memo, so that we request records from the
1295
1365
                # same pack file together, and in forward-sorted order
1296
1366
                records.sort(key=operator.itemgetter(1))
1299
1369
                    (record_details, index_memo, next) = position_map[key]
1300
1370
                    raw_record_map[key] = data, record_details, next
1301
1371
                return raw_record_map
1302
 
            except errors.RetryWithNewPacks, e:
 
1372
            except errors.RetryWithNewPacks as e:
1303
1373
                self._access.reload_or_raise(e)
1304
1374
 
1305
1375
    @classmethod
1325
1395
        prefix_order = []
1326
1396
        for key in keys:
1327
1397
            if len(key) == 1:
1328
 
                prefix = ''
 
1398
                prefix = b''
1329
1399
            else:
1330
1400
                prefix = key[0]
1331
1401
 
1404
1474
            try:
1405
1475
                keys = set(remaining_keys)
1406
1476
                for content_factory in self._get_remaining_record_stream(keys,
1407
 
                                            ordering, include_delta_closure):
 
1477
                                                                         ordering, include_delta_closure):
1408
1478
                    remaining_keys.discard(content_factory.key)
1409
1479
                    yield content_factory
1410
1480
                return
1411
 
            except errors.RetryWithNewPacks, e:
 
1481
            except errors.RetryWithNewPacks as e:
1412
1482
                self._access.reload_or_raise(e)
1413
1483
 
1414
1484
    def _get_remaining_record_stream(self, keys, ordering,
1415
1485
                                     include_delta_closure):
1416
1486
        """This function is the 'retry' portion for get_record_stream."""
1417
1487
        if include_delta_closure:
1418
 
            positions = self._get_components_positions(keys, allow_missing=True)
 
1488
            positions = self._get_components_positions(
 
1489
                keys, allow_missing=True)
1419
1490
        else:
1420
1491
            build_details = self._index.get_build_details(keys)
1421
1492
            # map from key to
1422
1493
            # (record_details, access_memo, compression_parent_key)
1423
1494
            positions = dict((key, self._build_details_to_components(details))
1424
 
                for key, details in build_details.iteritems())
 
1495
                             for key, details in viewitems(build_details))
1425
1496
        absent_keys = keys.difference(set(positions))
1426
1497
        # There may be more absent keys : if we're missing the basis component
1427
1498
        # and are trying to include the delta closure.
1479
1550
        else:
1480
1551
            if ordering != 'unordered':
1481
1552
                raise AssertionError('valid values for ordering are:'
1482
 
                    ' "unordered", "groupcompress" or "topological" not: %r'
1483
 
                    % (ordering,))
 
1553
                                     ' "unordered", "groupcompress" or "topological" not: %r'
 
1554
                                     % (ordering,))
1484
1555
            # Just group by source; remote sources first.
1485
1556
            present_keys = []
1486
1557
            source_keys = []
1523
1594
                    for key, raw_data in self._read_records_iter_unchecked(records):
1524
1595
                        (record_details, index_memo, _) = positions[key]
1525
1596
                        yield KnitContentFactory(key, global_map[key],
1526
 
                            record_details, None, raw_data, self._factory.annotated, None)
 
1597
                                                 record_details, None, raw_data, self._factory.annotated, None)
1527
1598
                else:
1528
 
                    vf = self._fallback_vfs[parent_maps.index(source) - 1]
 
1599
                    vf = self._immediate_fallback_vfs[parent_maps.index(
 
1600
                        source) - 1]
1529
1601
                    for record in vf.get_record_stream(keys, ordering,
1530
 
                        include_delta_closure):
 
1602
                                                       include_delta_closure):
1531
1603
                        yield record
1532
1604
 
1533
1605
    def get_sha1s(self, keys):
1535
1607
        missing = set(keys)
1536
1608
        record_map = self._get_record_map(missing, allow_missing=True)
1537
1609
        result = {}
1538
 
        for key, details in record_map.iteritems():
 
1610
        for key, details in viewitems(record_map):
1539
1611
            if key not in missing:
1540
1612
                continue
1541
1613
            # record entry 2 is the 'digest'.
1542
1614
            result[key] = details[2]
1543
1615
        missing.difference_update(set(result))
1544
 
        for source in self._fallback_vfs:
 
1616
        for source in self._immediate_fallback_vfs:
1545
1617
            if not missing:
1546
1618
                break
1547
1619
            new_result = source.get_sha1s(missing)
1572
1644
        else:
1573
1645
            # self is not annotated, but we can strip annotations cheaply.
1574
1646
            annotated = ""
1575
 
            convertibles = set(["knit-annotated-ft-gz"])
 
1647
            convertibles = {"knit-annotated-ft-gz"}
1576
1648
            if self._max_delta_chain:
1577
1649
                delta_types.add("knit-annotated-delta-gz")
1578
1650
                convertibles.add("knit-annotated-delta-gz")
1616
1688
            # Raise an error when a record is missing.
1617
1689
            if record.storage_kind == 'absent':
1618
1690
                raise RevisionNotPresent([record.key], self)
1619
 
            elif ((record.storage_kind in knit_types)
1620
 
                  and (compression_parent is None
1621
 
                       or not self._fallback_vfs
1622
 
                       or self._index.has_key(compression_parent)
1623
 
                       or not self.has_key(compression_parent))):
 
1691
            elif ((record.storage_kind in knit_types) and
 
1692
                  (compression_parent is None or
 
1693
                   not self._immediate_fallback_vfs or
 
1694
                   compression_parent in self._index or
 
1695
                   compression_parent not in self)):
1624
1696
                # we can insert the knit record literally if either it has no
1625
1697
                # compression parent OR we already have its basis in this kvf
1626
1698
                # OR the basis is not present even in the fallbacks.  In the
1628
1700
                # will be well, or it won't turn up at all and we'll raise an
1629
1701
                # error at the end.
1630
1702
                #
1631
 
                # TODO: self.has_key is somewhat redundant with
1632
 
                # self._index.has_key; we really want something that directly
 
1703
                # TODO: self.__contains__ is somewhat redundant with
 
1704
                # self._index.__contains__; we really want something that directly
1633
1705
                # asks if it's only present in the fallbacks. -- mbp 20081119
1634
1706
                if record.storage_kind not in native_types:
1635
1707
                    try:
1643
1715
                    # It's a knit record, it has a _raw_record field (even if
1644
1716
                    # it was reconstituted from a network stream).
1645
1717
                    bytes = record._raw_record
1646
 
                options = [record._build_details[0]]
 
1718
                options = [record._build_details[0].encode('ascii')]
1647
1719
                if record._build_details[1]:
1648
 
                    options.append('no-eol')
 
1720
                    options.append(b'no-eol')
1649
1721
                # Just blat it across.
1650
1722
                # Note: This does end up adding data on duplicate keys. As
1651
1723
                # modern repositories use atomic insertions this should not
1657
1729
                access_memo = self._access.add_raw_records(
1658
1730
                    [(record.key, len(bytes))], bytes)[0]
1659
1731
                index_entry = (record.key, options, access_memo, parents)
1660
 
                if 'fulltext' not in options:
 
1732
                if b'fulltext' not in options:
1661
1733
                    # Not a fulltext, so we need to make sure the compression
1662
1734
                    # parent will also be present.
1663
1735
                    # Note that pack backed knits don't need to buffer here
1668
1740
                    #
1669
1741
                    # They're required to be physically in this
1670
1742
                    # KnitVersionedFiles, not in a fallback.
1671
 
                    if not self._index.has_key(compression_parent):
 
1743
                    if compression_parent not in self._index:
1672
1744
                        pending = buffered_index_entries.setdefault(
1673
1745
                            compression_parent, [])
1674
1746
                        pending.append(index_entry)
1677
1749
                    self._index.add_records([index_entry])
1678
1750
            elif record.storage_kind == 'chunked':
1679
1751
                self.add_lines(record.key, parents,
1680
 
                    osutils.chunks_to_lines(record.get_bytes_as('chunked')))
 
1752
                               osutils.chunks_to_lines(record.get_bytes_as('chunked')))
1681
1753
            else:
1682
1754
                # Not suitable for direct insertion as a
1683
1755
                # delta, either because it's not the right format, or this
1767
1839
                # we need key, position, length
1768
1840
                key_records = []
1769
1841
                build_details = self._index.get_build_details(keys)
1770
 
                for key, details in build_details.iteritems():
 
1842
                for key, details in viewitems(build_details):
1771
1843
                    if key in keys:
1772
1844
                        key_records.append((key, details[0]))
1773
1845
                records_iter = enumerate(self._read_records_iter(key_records))
1774
1846
                for (key_idx, (key, data, sha_value)) in records_iter:
1775
 
                    pb.update('Walking content', key_idx, total)
 
1847
                    pb.update(gettext('Walking content'), key_idx, total)
1776
1848
                    compression_parent = build_details[key][1]
1777
1849
                    if compression_parent is None:
1778
1850
                        # fulltext
1779
 
                        line_iterator = self._factory.get_fulltext_content(data)
 
1851
                        line_iterator = self._factory.get_fulltext_content(
 
1852
                            data)
1780
1853
                    else:
1781
1854
                        # Delta
1782
 
                        line_iterator = self._factory.get_linedelta_content(data)
 
1855
                        line_iterator = self._factory.get_linedelta_content(
 
1856
                            data)
1783
1857
                    # Now that we are yielding the data for this key, remove it
1784
1858
                    # from the list
1785
1859
                    keys.remove(key)
1790
1864
                    for line in line_iterator:
1791
1865
                        yield line, key
1792
1866
                done = True
1793
 
            except errors.RetryWithNewPacks, e:
 
1867
            except errors.RetryWithNewPacks as e:
1794
1868
                self._access.reload_or_raise(e)
1795
1869
        # If there are still keys we've not yet found, we look in the fallback
1796
1870
        # vfs, and hope to find them there.  Note that if the keys are found
1797
1871
        # but had no changes or no content, the fallback may not return
1798
1872
        # anything.
1799
 
        if keys and not self._fallback_vfs:
 
1873
        if keys and not self._immediate_fallback_vfs:
1800
1874
            # XXX: strictly the second parameter is meant to be the file id
1801
1875
            # but it's not easily accessible here.
1802
1876
            raise RevisionNotPresent(keys, repr(self))
1803
 
        for source in self._fallback_vfs:
 
1877
        for source in self._immediate_fallback_vfs:
1804
1878
            if not keys:
1805
1879
                break
1806
1880
            source_keys = set()
1808
1882
                source_keys.add(key)
1809
1883
                yield line, key
1810
1884
            keys.difference_update(source_keys)
1811
 
        pb.update('Walking content', total, total)
 
1885
        pb.update(gettext('Walking content'), total, total)
1812
1886
 
1813
1887
    def _make_line_delta(self, delta_seq, new_content):
1814
1888
        """Generate a line delta from delta_seq and new_content."""
1816
1890
        for op in delta_seq.get_opcodes():
1817
1891
            if op[0] == 'equal':
1818
1892
                continue
1819
 
            diff_hunks.append((op[1], op[2], op[4]-op[3], new_content._lines[op[3]:op[4]]))
 
1893
            diff_hunks.append(
 
1894
                (op[1], op[2], op[4] - op[3], new_content._lines[op[3]:op[4]]))
1820
1895
        return diff_hunks
1821
1896
 
1822
1897
    def _merge_annotations(self, content, parents, parent_texts={},
1846
1921
                    # this copies (origin, text) pairs across to the new
1847
1922
                    # content for any line that matches the last-checked
1848
1923
                    # parent.
1849
 
                    content._lines[j:j+n] = merge_content._lines[i:i+n]
 
1924
                    content._lines[j:j + n] = merge_content._lines[i:i + n]
1850
1925
            # XXX: Robert says the following block is a workaround for a
1851
1926
            # now-fixed bug and it can probably be deleted. -- mbp 20080618
1852
 
            if content._lines and content._lines[-1][1][-1] != '\n':
 
1927
            if content._lines and not content._lines[-1][1].endswith(b'\n'):
1853
1928
                # The copied annotation was from a line without a trailing EOL,
1854
1929
                # reinstate one for the content object, to ensure correct
1855
1930
                # serialization.
1856
 
                line = content._lines[-1][1] + '\n'
 
1931
                line = content._lines[-1][1] + b'\n'
1857
1932
                content._lines[-1] = (content._lines[-1][0], line)
1858
1933
        if delta:
1859
1934
            if delta_seq is None:
1861
1936
                new_texts = content.text()
1862
1937
                old_texts = reference_content.text()
1863
1938
                delta_seq = patiencediff.PatienceSequenceMatcher(
1864
 
                                                 None, old_texts, new_texts)
 
1939
                    None, old_texts, new_texts)
1865
1940
            return self._make_line_delta(delta_seq, content)
1866
1941
 
1867
1942
    def _parse_record(self, version_id, data):
1879
1954
        :return: the header and the decompressor stream.
1880
1955
                 as (stream, header_record)
1881
1956
        """
1882
 
        df = tuned_gzip.GzipFile(mode='rb', fileobj=StringIO(raw_data))
 
1957
        df = gzip.GzipFile(mode='rb', fileobj=BytesIO(raw_data))
1883
1958
        try:
1884
1959
            # Current serialise
1885
1960
            rec = self._check_header(key, df.readline())
1886
 
        except Exception, e:
 
1961
        except Exception as e:
1887
1962
            raise KnitCorrupt(self,
1888
1963
                              "While reading {%s} got %s(%s)"
1889
1964
                              % (key, e.__class__.__name__, str(e)))
1894
1969
        # 4168 calls in 2880 217 internal
1895
1970
        # 4168 calls to _parse_record_header in 2121
1896
1971
        # 4168 calls to readlines in 330
1897
 
        df = tuned_gzip.GzipFile(mode='rb', fileobj=StringIO(data))
1898
 
        try:
1899
 
            record_contents = df.readlines()
1900
 
        except Exception, e:
1901
 
            raise KnitCorrupt(self, "Corrupt compressed record %r, got %s(%s)" %
1902
 
                (data, e.__class__.__name__, str(e)))
1903
 
        header = record_contents.pop(0)
1904
 
        rec = self._split_header(header)
1905
 
        last_line = record_contents.pop()
1906
 
        if len(record_contents) != int(rec[2]):
1907
 
            raise KnitCorrupt(self,
1908
 
                              'incorrect number of lines %s != %s'
1909
 
                              ' for version {%s} %s'
1910
 
                              % (len(record_contents), int(rec[2]),
1911
 
                                 rec[1], record_contents))
1912
 
        if last_line != 'end %s\n' % rec[1]:
1913
 
            raise KnitCorrupt(self,
1914
 
                              'unexpected version end line %r, wanted %r'
1915
 
                              % (last_line, rec[1]))
1916
 
        df.close()
 
1972
        with gzip.GzipFile(mode='rb', fileobj=BytesIO(data)) as df:
 
1973
            try:
 
1974
                record_contents = df.readlines()
 
1975
            except Exception as e:
 
1976
                raise KnitCorrupt(self, "Corrupt compressed record %r, got %s(%s)" %
 
1977
                                  (data, e.__class__.__name__, str(e)))
 
1978
            header = record_contents.pop(0)
 
1979
            rec = self._split_header(header)
 
1980
            last_line = record_contents.pop()
 
1981
            if len(record_contents) != int(rec[2]):
 
1982
                raise KnitCorrupt(self,
 
1983
                                  'incorrect number of lines %s != %s'
 
1984
                                  ' for version {%s} %s'
 
1985
                                  % (len(record_contents), int(rec[2]),
 
1986
                                     rec[1], record_contents))
 
1987
            if last_line != b'end %s\n' % rec[1]:
 
1988
                raise KnitCorrupt(self,
 
1989
                                  'unexpected version end line %r, wanted %r'
 
1990
                                  % (last_line, rec[1]))
1917
1991
        return rec, record_contents
1918
1992
 
1919
1993
    def _read_records_iter(self, records):
1922
1996
        The result will be returned in whatever is the fastest to read.
1923
1997
        Not by the order requested. Also, multiple requests for the same
1924
1998
        record will only yield 1 response.
 
1999
 
1925
2000
        :param records: A list of (key, access_memo) entries
1926
2001
        :return: Yields (key, contents, digest) in the order
1927
2002
                 read, not the order requested
1939
2014
        raw_data = self._access.get_raw_records(
1940
2015
            [index_memo for key, index_memo in needed_records])
1941
2016
 
1942
 
        for (key, index_memo), data in \
1943
 
                izip(iter(needed_records), raw_data):
 
2017
        for (key, index_memo), data in zip(needed_records, raw_data):
1944
2018
            content, digest = self._parse_record(key[-1], data)
1945
2019
            yield key, content, digest
1946
2020
 
1972
2046
        if len(records):
1973
2047
            # grab the disk data needed.
1974
2048
            needed_offsets = [index_memo for key, index_memo
1975
 
                                           in records]
 
2049
                              in records]
1976
2050
            raw_records = self._access.get_raw_records(needed_offsets)
1977
2051
 
1978
2052
        for key, index_memo in records:
1979
 
            data = raw_records.next()
 
2053
            data = next(raw_records)
1980
2054
            yield key, data
1981
2055
 
1982
2056
    def _record_to_data(self, key, digest, lines, dense_lines=None):
1985
2059
        :param key: The key of the record. Currently keys are always serialised
1986
2060
            using just the trailing component.
1987
2061
        :param dense_lines: The bytes of lines but in a denser form. For
1988
 
            instance, if lines is a list of 1000 bytestrings each ending in \n,
1989
 
            dense_lines may be a list with one line in it, containing all the
1990
 
            1000's lines and their \n's. Using dense_lines if it is already
1991
 
            known is a win because the string join to create bytes in this
1992
 
            function spends less time resizing the final string.
1993
 
        :return: (len, a StringIO instance with the raw data ready to read.)
 
2062
            instance, if lines is a list of 1000 bytestrings each ending in
 
2063
            \\n, dense_lines may be a list with one line in it, containing all
 
2064
            the 1000's lines and their \\n's. Using dense_lines if it is
 
2065
            already known is a win because the string join to create bytes in
 
2066
            this function spends less time resizing the final string.
 
2067
        :return: (len, a BytesIO instance with the raw data ready to read.)
1994
2068
        """
1995
 
        chunks = ["version %s %d %s\n" % (key[-1], len(lines), digest)]
 
2069
        chunks = [b"version %s %d %s\n" % (key[-1], len(lines), digest)]
1996
2070
        chunks.extend(dense_lines or lines)
1997
 
        chunks.append("end %s\n" % key[-1])
 
2071
        chunks.append(b"end " + key[-1] + b"\n")
1998
2072
        for chunk in chunks:
1999
 
            if type(chunk) is not str:
 
2073
            if not isinstance(chunk, bytes):
2000
2074
                raise AssertionError(
2001
2075
                    'data must be plain bytes was %s' % type(chunk))
2002
 
        if lines and lines[-1][-1] != '\n':
 
2076
        if lines and not lines[-1].endswith(b'\n'):
2003
2077
            raise ValueError('corrupt lines value %r' % lines)
2004
 
        compressed_bytes = tuned_gzip.chunks_to_gzip(chunks)
 
2078
        compressed_bytes = b''.join(tuned_gzip.chunks_to_gzip(chunks))
2005
2079
        return len(compressed_bytes), compressed_bytes
2006
2080
 
2007
2081
    def _split_header(self, line):
2015
2089
        """See VersionedFiles.keys."""
2016
2090
        if 'evil' in debug.debug_flags:
2017
2091
            trace.mutter_callsite(2, "keys scales with size of history")
2018
 
        sources = [self._index] + self._fallback_vfs
 
2092
        sources = [self._index] + self._immediate_fallback_vfs
2019
2093
        result = set()
2020
2094
        for source in sources:
2021
2095
            result.update(source.keys())
2033
2107
        # Note that _get_content is only called when the _ContentMapGenerator
2034
2108
        # has been constructed with just one key requested for reconstruction.
2035
2109
        if key in self.nonlocal_keys:
2036
 
            record = self.get_record_stream().next()
 
2110
            record = next(self.get_record_stream())
2037
2111
            # Create a content object on the fly
2038
2112
            lines = osutils.chunks_to_lines(record.get_bytes_as('chunked'))
2039
2113
            return PlainKnitContent(lines, record.key)
2061
2135
 
2062
2136
        missing_keys = set(nonlocal_keys)
2063
2137
        # Read from remote versioned file instances and provide to our caller.
2064
 
        for source in self.vf._fallback_vfs:
 
2138
        for source in self.vf._immediate_fallback_vfs:
2065
2139
            if not missing_keys:
2066
2140
                break
2067
2141
            # Loop over fallback repositories asking them for texts - ignore
2068
2142
            # any missing from a particular fallback.
2069
2143
            for record in source.get_record_stream(missing_keys,
2070
 
                self._ordering, True):
 
2144
                                                   self._ordering, True):
2071
2145
                if record.storage_kind == 'absent':
2072
2146
                    # Not in thie particular stream, may be in one of the
2073
2147
                    # other fallback vfs objects.
2127
2201
                    content = self._contents_map[component_id]
2128
2202
                else:
2129
2203
                    content, delta = self._factory.parse_record(key[-1],
2130
 
                        record, record_details, content,
2131
 
                        copy_base_content=multiple_versions)
 
2204
                                                                record, record_details, content,
 
2205
                                                                copy_base_content=multiple_versions)
2132
2206
                    if multiple_versions:
2133
2207
                        self._contents_map[component_id] = content
2134
2208
 
2156
2230
        """
2157
2231
        lines = []
2158
2232
        # kind marker for dispatch on the far side,
2159
 
        lines.append('knit-delta-closure')
 
2233
        lines.append(b'knit-delta-closure')
2160
2234
        # Annotated or not
2161
2235
        if self.vf._factory.annotated:
2162
 
            lines.append('annotated')
 
2236
            lines.append(b'annotated')
2163
2237
        else:
2164
 
            lines.append('')
 
2238
            lines.append(b'')
2165
2239
        # then the list of keys
2166
 
        lines.append('\t'.join(['\x00'.join(key) for key in self.keys
2167
 
            if key not in self.nonlocal_keys]))
 
2240
        lines.append(b'\t'.join(b'\x00'.join(key) for key in self.keys
 
2241
                                if key not in self.nonlocal_keys))
2168
2242
        # then the _raw_record_map in serialised form:
2169
2243
        map_byte_list = []
2170
2244
        # for each item in the map:
2175
2249
        # one line with next ('' for None)
2176
2250
        # one line with byte count of the record bytes
2177
2251
        # the record bytes
2178
 
        for key, (record_bytes, (method, noeol), next) in \
2179
 
            self._raw_record_map.iteritems():
2180
 
            key_bytes = '\x00'.join(key)
 
2252
        for key, (record_bytes, (method, noeol), next) in viewitems(
 
2253
                self._raw_record_map):
 
2254
            key_bytes = b'\x00'.join(key)
2181
2255
            parents = self.global_map.get(key, None)
2182
2256
            if parents is None:
2183
 
                parent_bytes = 'None:'
 
2257
                parent_bytes = b'None:'
2184
2258
            else:
2185
 
                parent_bytes = '\t'.join('\x00'.join(key) for key in parents)
2186
 
            method_bytes = method
 
2259
                parent_bytes = b'\t'.join(b'\x00'.join(key) for key in parents)
 
2260
            method_bytes = method.encode('ascii')
2187
2261
            if noeol:
2188
 
                noeol_bytes = "T"
 
2262
                noeol_bytes = b"T"
2189
2263
            else:
2190
 
                noeol_bytes = "F"
 
2264
                noeol_bytes = b"F"
2191
2265
            if next:
2192
 
                next_bytes = '\x00'.join(next)
 
2266
                next_bytes = b'\x00'.join(next)
2193
2267
            else:
2194
 
                next_bytes = ''
2195
 
            map_byte_list.append('%s\n%s\n%s\n%s\n%s\n%d\n%s' % (
2196
 
                key_bytes, parent_bytes, method_bytes, noeol_bytes, next_bytes,
2197
 
                len(record_bytes), record_bytes))
2198
 
        map_bytes = ''.join(map_byte_list)
 
2268
                next_bytes = b''
 
2269
            map_byte_list.append(b'\n'.join(
 
2270
                [key_bytes, parent_bytes, method_bytes, noeol_bytes, next_bytes,
 
2271
                 b'%d' % len(record_bytes), record_bytes]))
 
2272
        map_bytes = b''.join(map_byte_list)
2199
2273
        lines.append(map_bytes)
2200
 
        bytes = '\n'.join(lines)
 
2274
        bytes = b'\n'.join(lines)
2201
2275
        return bytes
2202
2276
 
2203
2277
 
2205
2279
    """Content map generator reading from a VersionedFiles object."""
2206
2280
 
2207
2281
    def __init__(self, versioned_files, keys, nonlocal_keys=None,
2208
 
        global_map=None, raw_record_map=None, ordering='unordered'):
 
2282
                 global_map=None, raw_record_map=None, ordering='unordered'):
2209
2283
        """Create a _ContentMapGenerator.
2210
2284
 
2211
2285
        :param versioned_files: The versioned files that the texts are being
2240
2314
        self._record_map = None
2241
2315
        if raw_record_map is None:
2242
2316
            self._raw_record_map = self.vf._get_record_map_unparsed(keys,
2243
 
                allow_missing=True)
 
2317
                                                                    allow_missing=True)
2244
2318
        else:
2245
2319
            self._raw_record_map = raw_record_map
2246
2320
        # the factory for parsing records
2262
2336
        self.vf = KnitVersionedFiles(None, None)
2263
2337
        start = line_end
2264
2338
        # Annotated or not
2265
 
        line_end = bytes.find('\n', start)
 
2339
        line_end = bytes.find(b'\n', start)
2266
2340
        line = bytes[start:line_end]
2267
2341
        start = line_end + 1
2268
 
        if line == 'annotated':
 
2342
        if line == b'annotated':
2269
2343
            self._factory = KnitAnnotateFactory()
2270
2344
        else:
2271
2345
            self._factory = KnitPlainFactory()
2272
2346
        # list of keys to emit in get_record_stream
2273
 
        line_end = bytes.find('\n', start)
 
2347
        line_end = bytes.find(b'\n', start)
2274
2348
        line = bytes[start:line_end]
2275
2349
        start = line_end + 1
2276
2350
        self.keys = [
2277
 
            tuple(segment.split('\x00')) for segment in line.split('\t')
 
2351
            tuple(segment.split(b'\x00')) for segment in line.split(b'\t')
2278
2352
            if segment]
2279
2353
        # now a loop until the end. XXX: It would be nice if this was just a
2280
2354
        # bunch of the same records as get_record_stream(..., False) gives, but
2282
2356
        end = len(bytes)
2283
2357
        while start < end:
2284
2358
            # 1 line with key
2285
 
            line_end = bytes.find('\n', start)
2286
 
            key = tuple(bytes[start:line_end].split('\x00'))
 
2359
            line_end = bytes.find(b'\n', start)
 
2360
            key = tuple(bytes[start:line_end].split(b'\x00'))
2287
2361
            start = line_end + 1
2288
2362
            # 1 line with parents (None: for None, '' for ())
2289
 
            line_end = bytes.find('\n', start)
 
2363
            line_end = bytes.find(b'\n', start)
2290
2364
            line = bytes[start:line_end]
2291
 
            if line == 'None:':
 
2365
            if line == b'None:':
2292
2366
                parents = None
2293
2367
            else:
2294
2368
                parents = tuple(
2295
 
                    [tuple(segment.split('\x00')) for segment in line.split('\t')
2296
 
                     if segment])
 
2369
                    tuple(segment.split(b'\x00')) for segment in line.split(b'\t')
 
2370
                    if segment)
2297
2371
            self.global_map[key] = parents
2298
2372
            start = line_end + 1
2299
2373
            # one line with method
2300
 
            line_end = bytes.find('\n', start)
 
2374
            line_end = bytes.find(b'\n', start)
2301
2375
            line = bytes[start:line_end]
2302
 
            method = line
 
2376
            method = line.decode('ascii')
2303
2377
            start = line_end + 1
2304
2378
            # one line with noeol
2305
 
            line_end = bytes.find('\n', start)
 
2379
            line_end = bytes.find(b'\n', start)
2306
2380
            line = bytes[start:line_end]
2307
 
            noeol = line == "T"
 
2381
            noeol = line == b"T"
2308
2382
            start = line_end + 1
2309
 
            # one line with next ('' for None)
2310
 
            line_end = bytes.find('\n', start)
 
2383
            # one line with next (b'' for None)
 
2384
            line_end = bytes.find(b'\n', start)
2311
2385
            line = bytes[start:line_end]
2312
2386
            if not line:
2313
2387
                next = None
2314
2388
            else:
2315
 
                next = tuple(bytes[start:line_end].split('\x00'))
 
2389
                next = tuple(bytes[start:line_end].split(b'\x00'))
2316
2390
            start = line_end + 1
2317
2391
            # one line with byte count of the record bytes
2318
 
            line_end = bytes.find('\n', start)
 
2392
            line_end = bytes.find(b'\n', start)
2319
2393
            line = bytes[start:line_end]
2320
2394
            count = int(line)
2321
2395
            start = line_end + 1
2322
2396
            # the record bytes
2323
 
            record_bytes = bytes[start:start+count]
 
2397
            record_bytes = bytes[start:start + count]
2324
2398
            start = start + count
2325
2399
            # put it in the map
2326
2400
            self._raw_record_map[key] = (record_bytes, (method, noeol), next)
2395
2469
        ABI change with the C extension that reads .kndx files.
2396
2470
    """
2397
2471
 
2398
 
    HEADER = "# bzr knit index 8\n"
 
2472
    HEADER = b"# bzr knit index 8\n"
2399
2473
 
2400
2474
    def __init__(self, transport, mapper, get_scope, allow_writes, is_locked):
2401
2475
        """Create a _KndxIndex on transport using mapper."""
2440
2514
 
2441
2515
            try:
2442
2516
                for key, options, (_, pos, size), parents in path_keys:
 
2517
                    if not all(isinstance(option, bytes) for option in options):
 
2518
                        raise TypeError(options)
2443
2519
                    if parents is None:
2444
2520
                        # kndx indices cannot be parentless.
2445
2521
                        parents = ()
2446
 
                    line = "\n%s %s %s %s %s :" % (
2447
 
                        key[-1], ','.join(options), pos, size,
2448
 
                        self._dictionary_compress(parents))
2449
 
                    if type(line) is not str:
 
2522
                    line = b' '.join([
 
2523
                        b'\n'
 
2524
                        + key[-1], b','.join(options), b'%d' % pos, b'%d' % size,
 
2525
                        self._dictionary_compress(parents), b':'])
 
2526
                    if not isinstance(line, bytes):
2450
2527
                        raise AssertionError(
2451
2528
                            'data must be utf8 was %s' % type(line))
2452
2529
                    lines.append(line)
2453
2530
                    self._cache_key(key, options, pos, size, parents)
2454
2531
                if len(orig_history):
2455
 
                    self._transport.append_bytes(path, ''.join(lines))
 
2532
                    self._transport.append_bytes(path, b''.join(lines))
2456
2533
                else:
2457
2534
                    self._init_index(path, lines)
2458
2535
            except:
2496
2573
        else:
2497
2574
            index = cache[version_id][5]
2498
2575
        cache[version_id] = (version_id,
2499
 
                                   options,
2500
 
                                   pos,
2501
 
                                   size,
2502
 
                                   parents,
2503
 
                                   index)
 
2576
                             options,
 
2577
                             pos,
 
2578
                             size,
 
2579
                             parents,
 
2580
                             index)
2504
2581
 
2505
2582
    def check_header(self, fp):
2506
2583
        line = fp.readline()
2507
 
        if line == '':
 
2584
        if line == b'':
2508
2585
            # An empty file can actually be treated as though the file doesn't
2509
2586
            # exist yet.
2510
2587
            raise errors.NoSuchFile(self)
2549
2626
        result = {}
2550
2627
        for key in keys:
2551
2628
            if key not in parent_map:
2552
 
                continue # Ghost
 
2629
                continue  # Ghost
2553
2630
            method = self.get_method(key)
 
2631
            if not isinstance(method, str):
 
2632
                raise TypeError(method)
2554
2633
            parents = parent_map[key]
2555
2634
            if method == 'fulltext':
2556
2635
                compression_parent = None
2557
2636
            else:
2558
2637
                compression_parent = parents[0]
2559
 
            noeol = 'no-eol' in self.get_options(key)
 
2638
            noeol = b'no-eol' in self.get_options(key)
2560
2639
            index_memo = self.get_position(key)
2561
2640
            result[key] = (index_memo, compression_parent,
2562
 
                                  parents, (method, noeol))
 
2641
                           parents, (method, noeol))
2563
2642
        return result
2564
2643
 
2565
2644
    def get_method(self, key):
2566
2645
        """Return compression method of specified key."""
2567
2646
        options = self.get_options(key)
2568
 
        if 'fulltext' in options:
 
2647
        if b'fulltext' in options:
2569
2648
            return 'fulltext'
2570
 
        elif 'line-delta' in options:
 
2649
        elif b'line-delta' in options:
2571
2650
            return 'line-delta'
2572
2651
        else:
2573
 
            raise errors.KnitIndexUnknownMethod(self, options)
 
2652
            raise KnitIndexUnknownMethod(self, options)
2574
2653
 
2575
2654
    def get_options(self, key):
2576
2655
        """Return a list representing options.
2608
2687
                                     for suffix in suffix_parents])
2609
2688
                parent_map[key] = parent_keys
2610
2689
                pending_keys.extend([p for p in parent_keys
2611
 
                                        if p not in parent_map])
 
2690
                                     if p not in parent_map])
2612
2691
        return parent_map, missing_keys
2613
2692
 
2614
2693
    def get_parent_map(self, keys):
2632
2711
                pass
2633
2712
            else:
2634
2713
                result[key] = tuple(prefix + (suffix,) for
2635
 
                    suffix in suffix_parents)
 
2714
                                    suffix in suffix_parents)
2636
2715
        return result
2637
2716
 
2638
2717
    def get_position(self, key):
2646
2725
        entry = self._kndx_cache[prefix][0][suffix]
2647
2726
        return key, entry[2], entry[3]
2648
2727
 
2649
 
    has_key = _mod_index._has_key_from_parent_map
 
2728
    __contains__ = _mod_index._has_key_from_parent_map
2650
2729
 
2651
2730
    def _init_index(self, path, extra_lines=[]):
2652
2731
        """Initialize an index."""
2653
 
        sio = StringIO()
 
2732
        sio = BytesIO()
2654
2733
        sio.write(self.HEADER)
2655
2734
        sio.writelines(extra_lines)
2656
2735
        sio.seek(0)
2657
2736
        self._transport.put_file_non_atomic(path, sio,
2658
 
                            create_parent_dir=True)
2659
 
                           # self._create_parent_dir)
2660
 
                           # mode=self._file_mode,
2661
 
                           # dir_mode=self._dir_mode)
 
2737
                                            create_parent_dir=True)
 
2738
        # self._create_parent_dir)
 
2739
        # mode=self._file_mode,
 
2740
        # dir_mode=self._dir_mode)
2662
2741
 
2663
2742
    def keys(self):
2664
2743
        """Get all the keys in the collection.
2668
2747
        result = set()
2669
2748
        # Identify all key prefixes.
2670
2749
        # XXX: A bit hacky, needs polish.
2671
 
        if type(self._mapper) is ConstantMapper:
 
2750
        if isinstance(self._mapper, ConstantMapper):
2672
2751
            prefixes = [()]
2673
2752
        else:
2674
2753
            relpaths = set()
2693
2772
                self._filename = prefix
2694
2773
                try:
2695
2774
                    path = self._mapper.map(prefix) + '.kndx'
2696
 
                    fp = self._transport.get(path)
2697
 
                    try:
 
2775
                    with self._transport.get(path) as fp:
2698
2776
                        # _load_data may raise NoSuchFile if the target knit is
2699
2777
                        # completely empty.
2700
2778
                        _load_data(self, fp)
2701
 
                    finally:
2702
 
                        fp.close()
2703
2779
                    self._kndx_cache[prefix] = (self._cache, self._history)
2704
2780
                    del self._cache
2705
2781
                    del self._filename
2706
2782
                    del self._history
2707
2783
                except NoSuchFile:
2708
2784
                    self._kndx_cache[prefix] = ({}, [])
2709
 
                    if type(self._mapper) is ConstantMapper:
 
2785
                    if isinstance(self._mapper, ConstantMapper):
2710
2786
                        # preserve behaviour for revisions.kndx etc.
2711
2787
                        self._init_index(path)
2712
2788
                    del self._cache
2732
2808
            '.' prefix.
2733
2809
        """
2734
2810
        if not keys:
2735
 
            return ''
 
2811
            return b''
2736
2812
        result_list = []
2737
2813
        prefix = keys[0][:-1]
2738
2814
        cache = self._kndx_cache[prefix][0]
2742
2818
                raise ValueError("mismatched prefixes for %r" % keys)
2743
2819
            if key[-1] in cache:
2744
2820
                # -- inlined lookup() --
2745
 
                result_list.append(str(cache[key[-1]][5]))
 
2821
                result_list.append(b'%d' % cache[key[-1]][5])
2746
2822
                # -- end lookup () --
2747
2823
            else:
2748
 
                result_list.append('.' + key[-1])
2749
 
        return ' '.join(result_list)
 
2824
                result_list.append(b'.' + key[-1])
 
2825
        return b' '.join(result_list)
2750
2826
 
2751
2827
    def _reset_cache(self):
2752
2828
        # Possibly this should be a LRU cache. A dictionary from key_prefix to
2783
2859
 
2784
2860
    def _split_key(self, key):
2785
2861
        """Split key into a prefix and suffix."""
 
2862
        # GZ 2018-07-03: This is intentionally either a sequence or bytes?
 
2863
        if isinstance(key, bytes):
 
2864
            return key[:-1], key[-1:]
2786
2865
        return key[:-1], key[-1]
2787
2866
 
2788
2867
 
2789
 
class _KeyRefs(object):
2790
 
 
2791
 
    def __init__(self, track_new_keys=False):
2792
 
        # dict mapping 'key' to 'set of keys referring to that key'
2793
 
        self.refs = {}
2794
 
        if track_new_keys:
2795
 
            # set remembering all new keys
2796
 
            self.new_keys = set()
2797
 
        else:
2798
 
            self.new_keys = None
2799
 
 
2800
 
    def clear(self):
2801
 
        if self.refs:
2802
 
            self.refs.clear()
2803
 
        if self.new_keys:
2804
 
            self.new_keys.clear()
2805
 
 
2806
 
    def add_references(self, key, refs):
2807
 
        # Record the new references
2808
 
        for referenced in refs:
2809
 
            try:
2810
 
                needed_by = self.refs[referenced]
2811
 
            except KeyError:
2812
 
                needed_by = self.refs[referenced] = set()
2813
 
            needed_by.add(key)
2814
 
        # Discard references satisfied by the new key
2815
 
        self.add_key(key)
2816
 
 
2817
 
    def get_new_keys(self):
2818
 
        return self.new_keys
2819
 
    
2820
 
    def get_unsatisfied_refs(self):
2821
 
        return self.refs.iterkeys()
2822
 
 
2823
 
    def _satisfy_refs_for_key(self, key):
2824
 
        try:
2825
 
            del self.refs[key]
2826
 
        except KeyError:
2827
 
            # No keys depended on this key.  That's ok.
2828
 
            pass
2829
 
 
2830
 
    def add_key(self, key):
2831
 
        # satisfy refs for key, and remember that we've seen this key.
2832
 
        self._satisfy_refs_for_key(key)
2833
 
        if self.new_keys is not None:
2834
 
            self.new_keys.add(key)
2835
 
 
2836
 
    def satisfy_refs_for_keys(self, keys):
2837
 
        for key in keys:
2838
 
            self._satisfy_refs_for_key(key)
2839
 
 
2840
 
    def get_referrers(self):
2841
 
        result = set()
2842
 
        for referrers in self.refs.itervalues():
2843
 
            result.update(referrers)
2844
 
        return result
2845
 
 
2846
 
 
2847
2868
class _KnitGraphIndex(object):
2848
2869
    """A KnitVersionedFiles index layered on GraphIndex."""
2849
2870
 
2850
2871
    def __init__(self, graph_index, is_locked, deltas=False, parents=True,
2851
 
        add_callback=None, track_external_parent_refs=False):
 
2872
                 add_callback=None, track_external_parent_refs=False):
2852
2873
        """Construct a KnitGraphIndex on a graph_index.
2853
2874
 
2854
 
        :param graph_index: An implementation of bzrlib.index.GraphIndex.
 
2875
        :param graph_index: An implementation of breezy.index.GraphIndex.
2855
2876
        :param is_locked: A callback to check whether the object should answer
2856
2877
            queries.
2857
2878
        :param deltas: Allow delta-compressed records.
2874
2895
            # XXX: TODO: Delta tree and parent graph should be conceptually
2875
2896
            # separate.
2876
2897
            raise KnitCorrupt(self, "Cannot do delta compression without "
2877
 
                "parent tracking.")
 
2898
                              "parent tracking.")
2878
2899
        self.has_graph = parents
2879
2900
        self._is_locked = is_locked
2880
2901
        self._missing_compression_parents = set()
2887
2908
        return "%s(%r)" % (self.__class__.__name__, self._graph_index)
2888
2909
 
2889
2910
    def add_records(self, records, random_id=False,
2890
 
        missing_compression_parents=False):
 
2911
                    missing_compression_parents=False):
2891
2912
        """Add multiple records to the index.
2892
2913
 
2893
2914
        This function does not insert data into the Immutable GraphIndex
2918
2939
                if key_dependencies is not None:
2919
2940
                    key_dependencies.add_references(key, parents)
2920
2941
            index, pos, size = access_memo
2921
 
            if 'no-eol' in options:
2922
 
                value = 'N'
 
2942
            if b'no-eol' in options:
 
2943
                value = b'N'
2923
2944
            else:
2924
 
                value = ' '
2925
 
            value += "%d %d" % (pos, size)
 
2945
                value = b' '
 
2946
            value += b"%d %d" % (pos, size)
2926
2947
            if not self._deltas:
2927
 
                if 'line-delta' in options:
2928
 
                    raise KnitCorrupt(self, "attempt to add line-delta in non-delta knit")
 
2948
                if b'line-delta' in options:
 
2949
                    raise KnitCorrupt(
 
2950
                        self, "attempt to add line-delta in non-delta knit")
2929
2951
            if self._parents:
2930
2952
                if self._deltas:
2931
 
                    if 'line-delta' in options:
 
2953
                    if b'line-delta' in options:
2932
2954
                        node_refs = (parents, (parents[0],))
2933
2955
                        if missing_compression_parents:
2934
2956
                            compression_parents.add(parents[0])
2939
2961
            else:
2940
2962
                if parents:
2941
2963
                    raise KnitCorrupt(self, "attempt to add node with parents "
2942
 
                        "in parentless index.")
 
2964
                                      "in parentless index.")
2943
2965
                node_refs = ()
2944
2966
            keys[key] = (value, node_refs)
2945
2967
        # check for dups
2950
2972
                # Sometimes these are passed as a list rather than a tuple
2951
2973
                passed = static_tuple.as_tuples(keys[key])
2952
2974
                passed_parents = passed[1][:1]
2953
 
                if (value[0] != keys[key][0][0] or
2954
 
                    parents != passed_parents):
 
2975
                if (value[0:1] != keys[key][0][0:1]
 
2976
                        or parents != passed_parents):
2955
2977
                    node_refs = static_tuple.as_tuples(node_refs)
2956
2978
                    raise KnitCorrupt(self, "inconsistent details in add_records"
2957
 
                        ": %s %s" % ((value, node_refs), passed))
 
2979
                                      ": %s %s" % ((value, node_refs), passed))
2958
2980
                del keys[key]
2959
2981
        result = []
2960
2982
        if self._parents:
2961
 
            for key, (value, node_refs) in keys.iteritems():
 
2983
            for key, (value, node_refs) in viewitems(keys):
2962
2984
                result.append((key, value, node_refs))
2963
2985
        else:
2964
 
            for key, (value, node_refs) in keys.iteritems():
 
2986
            for key, (value, node_refs) in viewitems(keys):
2965
2987
                result.append((key, value))
2966
2988
        self._add_callback(result)
2967
2989
        if missing_compression_parents:
3065
3087
                compression_parent_key = None
3066
3088
            else:
3067
3089
                compression_parent_key = self._compression_parent(entry)
3068
 
            noeol = (entry[2][0] == 'N')
 
3090
            noeol = (entry[2][0:1] == b'N')
3069
3091
            if compression_parent_key:
3070
3092
                method = 'line-delta'
3071
3093
            else:
3072
3094
                method = 'fulltext'
3073
3095
            result[key] = (self._node_to_position(entry),
3074
 
                                  compression_parent_key, parents,
3075
 
                                  (method, noeol))
 
3096
                           compression_parent_key, parents,
 
3097
                           (method, noeol))
3076
3098
        return result
3077
3099
 
3078
3100
    def _get_entries(self, keys, check_present=False):
3120
3142
        e.g. ['foo', 'bar']
3121
3143
        """
3122
3144
        node = self._get_node(key)
3123
 
        options = [self._get_method(node)]
3124
 
        if node[2][0] == 'N':
3125
 
            options.append('no-eol')
 
3145
        options = [self._get_method(node).encode('ascii')]
 
3146
        if node[2][0:1] == b'N':
 
3147
            options.append(b'no-eol')
3126
3148
        return options
3127
3149
 
3128
3150
    def find_ancestry(self, keys):
3156
3178
        node = self._get_node(key)
3157
3179
        return self._node_to_position(node)
3158
3180
 
3159
 
    has_key = _mod_index._has_key_from_parent_map
 
3181
    __contains__ = _mod_index._has_key_from_parent_map
3160
3182
 
3161
3183
    def keys(self):
3162
3184
        """Get all the keys in the collection.
3170
3192
 
3171
3193
    def _node_to_position(self, node):
3172
3194
        """Convert an index value to position details."""
3173
 
        bits = node[2][1:].split(' ')
 
3195
        bits = node[2][1:].split(b' ')
3174
3196
        return node[0], int(bits[0]), int(bits[1])
3175
3197
 
3176
3198
    def _sort_keys_by_io(self, keys, positions):
3221
3243
            opaque index memo. For _KnitKeyAccess the memo is (key, pos,
3222
3244
            length), where the key is the record key.
3223
3245
        """
3224
 
        if type(raw_data) is not str:
 
3246
        if not isinstance(raw_data, bytes):
3225
3247
            raise AssertionError(
3226
3248
                'data must be plain bytes was %s' % type(raw_data))
3227
3249
        result = []
3233
3255
            path = self._mapper.map(key)
3234
3256
            try:
3235
3257
                base = self._transport.append_bytes(path + '.knit',
3236
 
                    raw_data[offset:offset+size])
 
3258
                                                    raw_data[offset:offset + size])
3237
3259
            except errors.NoSuchFile:
3238
3260
                self._transport.mkdir(osutils.dirname(path))
3239
3261
                base = self._transport.append_bytes(path + '.knit',
3240
 
                    raw_data[offset:offset+size])
 
3262
                                                    raw_data[offset:offset + size])
3241
3263
            # if base == 0:
3242
3264
            # chmod.
3243
3265
            offset += size
3246
3268
 
3247
3269
    def flush(self):
3248
3270
        """Flush pending writes on this access object.
3249
 
        
 
3271
 
3250
3272
        For .knit files this is a no-op.
3251
3273
        """
3252
3274
        pass
3278
3300
                yield data
3279
3301
 
3280
3302
 
3281
 
class _DirectPackAccess(object):
3282
 
    """Access to data in one or more packs with less translation."""
3283
 
 
3284
 
    def __init__(self, index_to_packs, reload_func=None, flush_func=None):
3285
 
        """Create a _DirectPackAccess object.
3286
 
 
3287
 
        :param index_to_packs: A dict mapping index objects to the transport
3288
 
            and file names for obtaining data.
3289
 
        :param reload_func: A function to call if we determine that the pack
3290
 
            files have moved and we need to reload our caches. See
3291
 
            bzrlib.repo_fmt.pack_repo.AggregateIndex for more details.
3292
 
        """
3293
 
        self._container_writer = None
3294
 
        self._write_index = None
3295
 
        self._indices = index_to_packs
3296
 
        self._reload_func = reload_func
3297
 
        self._flush_func = flush_func
3298
 
 
3299
 
    def add_raw_records(self, key_sizes, raw_data):
3300
 
        """Add raw knit bytes to a storage area.
3301
 
 
3302
 
        The data is spooled to the container writer in one bytes-record per
3303
 
        raw data item.
3304
 
 
3305
 
        :param sizes: An iterable of tuples containing the key and size of each
3306
 
            raw data segment.
3307
 
        :param raw_data: A bytestring containing the data.
3308
 
        :return: A list of memos to retrieve the record later. Each memo is an
3309
 
            opaque index memo. For _DirectPackAccess the memo is (index, pos,
3310
 
            length), where the index field is the write_index object supplied
3311
 
            to the PackAccess object.
3312
 
        """
3313
 
        if type(raw_data) is not str:
3314
 
            raise AssertionError(
3315
 
                'data must be plain bytes was %s' % type(raw_data))
3316
 
        result = []
3317
 
        offset = 0
3318
 
        for key, size in key_sizes:
3319
 
            p_offset, p_length = self._container_writer.add_bytes_record(
3320
 
                raw_data[offset:offset+size], [])
3321
 
            offset += size
3322
 
            result.append((self._write_index, p_offset, p_length))
3323
 
        return result
3324
 
 
3325
 
    def flush(self):
3326
 
        """Flush pending writes on this access object.
3327
 
 
3328
 
        This will flush any buffered writes to a NewPack.
3329
 
        """
3330
 
        if self._flush_func is not None:
3331
 
            self._flush_func()
3332
 
            
3333
 
    def get_raw_records(self, memos_for_retrieval):
3334
 
        """Get the raw bytes for a records.
3335
 
 
3336
 
        :param memos_for_retrieval: An iterable containing the (index, pos,
3337
 
            length) memo for retrieving the bytes. The Pack access method
3338
 
            looks up the pack to use for a given record in its index_to_pack
3339
 
            map.
3340
 
        :return: An iterator over the bytes of the records.
3341
 
        """
3342
 
        # first pass, group into same-index requests
3343
 
        request_lists = []
3344
 
        current_index = None
3345
 
        for (index, offset, length) in memos_for_retrieval:
3346
 
            if current_index == index:
3347
 
                current_list.append((offset, length))
3348
 
            else:
3349
 
                if current_index is not None:
3350
 
                    request_lists.append((current_index, current_list))
3351
 
                current_index = index
3352
 
                current_list = [(offset, length)]
3353
 
        # handle the last entry
3354
 
        if current_index is not None:
3355
 
            request_lists.append((current_index, current_list))
3356
 
        for index, offsets in request_lists:
3357
 
            try:
3358
 
                transport, path = self._indices[index]
3359
 
            except KeyError:
3360
 
                # A KeyError here indicates that someone has triggered an index
3361
 
                # reload, and this index has gone missing, we need to start
3362
 
                # over.
3363
 
                if self._reload_func is None:
3364
 
                    # If we don't have a _reload_func there is nothing that can
3365
 
                    # be done
3366
 
                    raise
3367
 
                raise errors.RetryWithNewPacks(index,
3368
 
                                               reload_occurred=True,
3369
 
                                               exc_info=sys.exc_info())
3370
 
            try:
3371
 
                reader = pack.make_readv_reader(transport, path, offsets)
3372
 
                for names, read_func in reader.iter_records():
3373
 
                    yield read_func(None)
3374
 
            except errors.NoSuchFile:
3375
 
                # A NoSuchFile error indicates that a pack file has gone
3376
 
                # missing on disk, we need to trigger a reload, and start over.
3377
 
                if self._reload_func is None:
3378
 
                    raise
3379
 
                raise errors.RetryWithNewPacks(transport.abspath(path),
3380
 
                                               reload_occurred=False,
3381
 
                                               exc_info=sys.exc_info())
3382
 
 
3383
 
    def set_writer(self, writer, index, transport_packname):
3384
 
        """Set a writer to use for adding data."""
3385
 
        if index is not None:
3386
 
            self._indices[index] = transport_packname
3387
 
        self._container_writer = writer
3388
 
        self._write_index = index
3389
 
 
3390
 
    def reload_or_raise(self, retry_exc):
3391
 
        """Try calling the reload function, or re-raise the original exception.
3392
 
 
3393
 
        This should be called after _DirectPackAccess raises a
3394
 
        RetryWithNewPacks exception. This function will handle the common logic
3395
 
        of determining when the error is fatal versus being temporary.
3396
 
        It will also make sure that the original exception is raised, rather
3397
 
        than the RetryWithNewPacks exception.
3398
 
 
3399
 
        If this function returns, then the calling function should retry
3400
 
        whatever operation was being performed. Otherwise an exception will
3401
 
        be raised.
3402
 
 
3403
 
        :param retry_exc: A RetryWithNewPacks exception.
3404
 
        """
3405
 
        is_error = False
3406
 
        if self._reload_func is None:
3407
 
            is_error = True
3408
 
        elif not self._reload_func():
3409
 
            # The reload claimed that nothing changed
3410
 
            if not retry_exc.reload_occurred:
3411
 
                # If there wasn't an earlier reload, then we really were
3412
 
                # expecting to find changes. We didn't find them, so this is a
3413
 
                # hard error
3414
 
                is_error = True
3415
 
        if is_error:
3416
 
            exc_class, exc_value, exc_traceback = retry_exc.exc_info
3417
 
            raise exc_class, exc_value, exc_traceback
3418
 
 
3419
 
 
3420
 
# Deprecated, use PatienceSequenceMatcher instead
3421
 
KnitSequenceMatcher = patiencediff.PatienceSequenceMatcher
3422
 
 
3423
 
 
3424
3303
def annotate_knit(knit, revision_id):
3425
3304
    """Annotate a knit with no cached annotations.
3426
3305
 
3469
3348
            passing to read_records_iter to start reading in the raw data from
3470
3349
            the pack file.
3471
3350
        """
3472
 
        pending = set([key])
 
3351
        pending = {key}
3473
3352
        records = []
3474
3353
        ann_keys = set()
3475
3354
        self._num_needed_children[key] = 1
3480
3359
            self._all_build_details.update(build_details)
3481
3360
            # new_nodes = self._vf._index._get_entries(this_iteration)
3482
3361
            pending = set()
3483
 
            for key, details in build_details.iteritems():
 
3362
            for key, details in viewitems(build_details):
3484
3363
                (index_memo, compression_parent, parent_keys,
3485
3364
                 record_details) = details
3486
3365
                self._parent_map[key] = parent_keys
3488
3367
                records.append((key, index_memo))
3489
3368
                # Do we actually need to check _annotated_lines?
3490
3369
                pending.update([p for p in parent_keys
3491
 
                                   if p not in self._all_build_details])
 
3370
                                if p not in self._all_build_details])
3492
3371
                if parent_keys:
3493
3372
                    for parent_key in parent_keys:
3494
3373
                        if parent_key in self._num_needed_children:
3501
3380
                    else:
3502
3381
                        self._num_compression_children[compression_parent] = 1
3503
3382
 
3504
 
            missing_versions = this_iteration.difference(build_details.keys())
 
3383
            missing_versions = this_iteration.difference(build_details)
3505
3384
            if missing_versions:
3506
3385
                for key in missing_versions:
3507
3386
                    if key in self._parent_map and key in self._text_cache:
3515
3394
                            else:
3516
3395
                                self._num_needed_children[parent_key] = 1
3517
3396
                        pending.update([p for p in parent_keys
3518
 
                                           if p not in self._all_build_details])
 
3397
                                        if p not in self._all_build_details])
3519
3398
                    else:
3520
3399
                        raise errors.RevisionNotPresent(key, self._vf)
3521
3400
        # Generally we will want to read the records in reverse order, because
3524
3403
        return records, ann_keys
3525
3404
 
3526
3405
    def _get_needed_texts(self, key, pb=None):
3527
 
        # if True or len(self._vf._fallback_vfs) > 0:
3528
 
        if len(self._vf._fallback_vfs) > 0:
 
3406
        # if True or len(self._vf._immediate_fallback_vfs) > 0:
 
3407
        if len(self._vf._immediate_fallback_vfs) > 0:
3529
3408
            # If we have fallbacks, go to the generic path
3530
3409
            for v in annotate.Annotator._get_needed_texts(self, key, pb=pb):
3531
3410
                yield v
3534
3413
            try:
3535
3414
                records, ann_keys = self._get_build_graph(key)
3536
3415
                for idx, (sub_key, text, num_lines) in enumerate(
3537
 
                                                self._extract_texts(records)):
 
3416
                        self._extract_texts(records)):
3538
3417
                    if pb is not None:
3539
 
                        pb.update('annotating', idx, len(records))
 
3418
                        pb.update(gettext('annotating'), idx, len(records))
3540
3419
                    yield sub_key, text, num_lines
3541
3420
                for sub_key in ann_keys:
3542
3421
                    text = self._text_cache[sub_key]
3543
 
                    num_lines = len(text) # bad assumption
 
3422
                    num_lines = len(text)  # bad assumption
3544
3423
                    yield sub_key, text, num_lines
3545
3424
                return
3546
 
            except errors.RetryWithNewPacks, e:
 
3425
            except errors.RetryWithNewPacks as e:
3547
3426
                self._vf._access.reload_or_raise(e)
3548
3427
                # The cached build_details are no longer valid
3549
3428
                self._all_build_details.clear()
3550
3429
 
3551
3430
    def _cache_delta_blocks(self, key, compression_parent, delta, lines):
3552
3431
        parent_lines = self._text_cache[compression_parent]
3553
 
        blocks = list(KnitContent.get_line_delta_blocks(delta, parent_lines, lines))
 
3432
        blocks = list(KnitContent.get_line_delta_blocks(
 
3433
            delta, parent_lines, lines))
3554
3434
        self._matching_blocks[(key, compression_parent)] = blocks
3555
3435
 
3556
3436
    def _expand_record(self, key, parent_keys, compression_parent, record,
3609
3489
            parent_annotations = self._annotations_cache[parent_key]
3610
3490
            return parent_annotations, blocks
3611
3491
        return annotate.Annotator._get_parent_annotations_and_matches(self,
3612
 
            key, text, parent_key)
 
3492
                                                                      key, text, parent_key)
3613
3493
 
3614
3494
    def _process_pending(self, key):
3615
3495
        """The content for 'key' was just processed.
3646
3526
                # Note that if there are multiple parents, we need to wait
3647
3527
                # for all of them.
3648
3528
                self._pending_annotation.setdefault(parent_key,
3649
 
                    []).append((key, parent_keys))
 
3529
                                                    []).append((key, parent_keys))
3650
3530
                return False
3651
3531
        return True
3652
3532
 
3707
3587
                    yield key, lines, len(lines)
3708
3588
                    to_process.extend(self._process_pending(key))
3709
3589
 
 
3590
 
3710
3591
try:
3711
 
    from bzrlib._knit_load_data_pyx import _load_data_c as _load_data
3712
 
except ImportError, e:
 
3592
    from ._knit_load_data_pyx import _load_data_c as _load_data
 
3593
except ImportError as e:
3713
3594
    osutils.failed_to_load_extension(e)
3714
 
    from bzrlib._knit_load_data_py import _load_data_py as _load_data
 
3595
    from ._knit_load_data_py import _load_data_py as _load_data