/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 bzrlib/repository.py

  • Committer: Jelmer Vernooij
  • Date: 2009-03-28 15:23:21 UTC
  • mto: This revision was merged to the branch mainline in revision 4212.
  • Revision ID: jelmer@samba.org-20090328152321-nywo3pe3qraf6z1f
Fix upgrade if there is no local repository present.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
23
23
from bzrlib import (
24
24
    bzrdir,
25
25
    check,
26
 
    chk_map,
27
 
    config,
28
26
    debug,
29
27
    errors,
30
 
    fetch as _mod_fetch,
31
28
    fifo_cache,
32
29
    generate_ids,
33
30
    gpg,
34
31
    graph,
35
 
    inventory,
36
 
    inventory_delta,
37
32
    lazy_regex,
38
33
    lockable_files,
39
34
    lockdir,
40
35
    lru_cache,
41
36
    osutils,
42
37
    revision as _mod_revision,
43
 
    static_tuple,
44
38
    symbol_versioning,
45
 
    trace,
46
39
    tsort,
47
40
    ui,
48
41
    versionedfile,
53
46
from bzrlib.testament import Testament
54
47
""")
55
48
 
56
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
49
from bzrlib.decorators import needs_read_lock, needs_write_lock
57
50
from bzrlib.inter import InterObject
58
51
from bzrlib.inventory import (
59
52
    Inventory,
61
54
    ROOT_ID,
62
55
    entry_factory,
63
56
    )
64
 
from bzrlib.lock import _RelockDebugMixin
65
57
from bzrlib import registry
 
58
from bzrlib.symbol_versioning import (
 
59
        deprecated_method,
 
60
        )
66
61
from bzrlib.trace import (
67
62
    log_exception_quietly, note, mutter, mutter_callsite, warning)
68
63
 
202
197
 
203
198
    def finish_inventory(self):
204
199
        """Tell the builder that the inventory is finished.
205
 
 
 
200
        
206
201
        :return: The inventory id in the repository, which can be used with
207
202
            repository.get_inventory.
208
203
        """
210
205
            # an inventory delta was accumulated without creating a new
211
206
            # inventory.
212
207
            basis_id = self.basis_delta_revision
213
 
            # We ignore the 'inventory' returned by add_inventory_by_delta
214
 
            # because self.new_inventory is used to hint to the rest of the
215
 
            # system what code path was taken
216
 
            self.inv_sha1, _ = self.repository.add_inventory_by_delta(
 
208
            self.inv_sha1 = self.repository.add_inventory_by_delta(
217
209
                basis_id, self._basis_delta, self._new_revision_id,
218
210
                self.parents)
219
211
        else:
332
324
            raise AssertionError("recording deletes not activated.")
333
325
        delta = (path, None, file_id, None)
334
326
        self._basis_delta.append(delta)
335
 
        self._any_changes = True
336
327
        return delta
337
328
 
338
329
    def will_record_deletes(self):
473
464
            if content_summary[2] is None:
474
465
                raise ValueError("Files must not have executable = None")
475
466
            if not store:
476
 
                # We can't trust a check of the file length because of content
477
 
                # filtering...
478
 
                if (# if the exec bit has changed we have to store:
 
467
                if (# if the file length changed we have to store:
 
468
                    parent_entry.text_size != content_summary[1] or
 
469
                    # if the exec bit has changed we have to store:
479
470
                    parent_entry.executable != content_summary[2]):
480
471
                    store = True
481
472
                elif parent_entry.text_sha1 == content_summary[3]:
500
491
            ie.executable = content_summary[2]
501
492
            file_obj, stat_value = tree.get_file_with_stat(ie.file_id, path)
502
493
            try:
503
 
                text = file_obj.read()
 
494
                lines = file_obj.readlines()
504
495
            finally:
505
496
                file_obj.close()
506
497
            try:
507
498
                ie.text_sha1, ie.text_size = self._add_text_to_weave(
508
 
                    ie.file_id, text, heads, nostore_sha)
 
499
                    ie.file_id, lines, heads, nostore_sha)
509
500
                # Let the caller know we generated a stat fingerprint.
510
501
                fingerprint = (ie.text_sha1, stat_value)
511
502
            except errors.ExistingContent:
523
514
                # carry over:
524
515
                ie.revision = parent_entry.revision
525
516
                return self._get_delta(ie, basis_inv, path), False, None
526
 
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
517
            lines = []
 
518
            self._add_text_to_weave(ie.file_id, lines, heads, None)
527
519
        elif kind == 'symlink':
528
520
            current_link_target = content_summary[3]
529
521
            if not store:
537
529
                ie.symlink_target = parent_entry.symlink_target
538
530
                return self._get_delta(ie, basis_inv, path), False, None
539
531
            ie.symlink_target = current_link_target
540
 
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
532
            lines = []
 
533
            self._add_text_to_weave(ie.file_id, lines, heads, None)
541
534
        elif kind == 'tree-reference':
542
535
            if not store:
543
536
                if content_summary[3] != parent_entry.reference_revision:
548
541
                ie.revision = parent_entry.revision
549
542
                return self._get_delta(ie, basis_inv, path), False, None
550
543
            ie.reference_revision = content_summary[3]
551
 
            if ie.reference_revision is None:
552
 
                raise AssertionError("invalid content_summary for nested tree: %r"
553
 
                    % (content_summary,))
554
 
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
544
            lines = []
 
545
            self._add_text_to_weave(ie.file_id, lines, heads, None)
555
546
        else:
556
547
            raise NotImplementedError('unknown kind')
557
548
        ie.revision = self._new_revision_id
567
558
            has been generated against. Currently assumed to be the same
568
559
            as self.parents[0] - if it is not, errors may occur.
569
560
        :param iter_changes: An iter_changes iterator with the changes to apply
570
 
            to basis_revision_id. The iterator must not include any items with
571
 
            a current kind of None - missing items must be either filtered out
572
 
            or errored-on beefore record_iter_changes sees the item.
 
561
            to basis_revision_id.
573
562
        :param _entry_factory: Private method to bind entry_factory locally for
574
563
            performance.
575
 
        :return: A generator of (file_id, relpath, fs_hash) tuples for use with
576
 
            tree._observed_sha1.
 
564
        :return: None
577
565
        """
578
566
        # Create an inventory delta based on deltas between all the parents and
579
567
        # deltas between all the parent inventories. We use inventory delta's 
586
574
        # {file_id -> revision_id -> inventory entry, for entries in parent
587
575
        # trees that are not parents[0]
588
576
        parent_entries = {}
589
 
        ghost_basis = False
590
 
        try:
591
 
            revtrees = list(self.repository.revision_trees(self.parents))
592
 
        except errors.NoSuchRevision:
593
 
            # one or more ghosts, slow path.
594
 
            revtrees = []
595
 
            for revision_id in self.parents:
596
 
                try:
597
 
                    revtrees.append(self.repository.revision_tree(revision_id))
598
 
                except errors.NoSuchRevision:
599
 
                    if not revtrees:
600
 
                        basis_revision_id = _mod_revision.NULL_REVISION
601
 
                        ghost_basis = True
602
 
                    revtrees.append(self.repository.revision_tree(
603
 
                        _mod_revision.NULL_REVISION))
 
577
        revtrees = list(self.repository.revision_trees(self.parents))
604
578
        # The basis inventory from a repository 
605
579
        if revtrees:
606
580
            basis_inv = revtrees[0].inventory
608
582
            basis_inv = self.repository.revision_tree(
609
583
                _mod_revision.NULL_REVISION).inventory
610
584
        if len(self.parents) > 0:
611
 
            if basis_revision_id != self.parents[0] and not ghost_basis:
 
585
            if basis_revision_id != self.parents[0]:
612
586
                raise Exception(
613
587
                    "arbitrary basis parents not yet supported with merges")
614
588
            for revtree in revtrees[1:]:
618
592
                        continue
619
593
                    if change[2] not in merged_ids:
620
594
                        if change[0] is not None:
621
 
                            basis_entry = basis_inv[change[2]]
622
595
                            merged_ids[change[2]] = [
623
 
                                # basis revid
624
 
                                basis_entry.revision,
625
 
                                # new tree revid
 
596
                                basis_inv[change[2]].revision,
626
597
                                change[3].revision]
627
 
                            parent_entries[change[2]] = {
628
 
                                # basis parent
629
 
                                basis_entry.revision:basis_entry,
630
 
                                # this parent 
631
 
                                change[3].revision:change[3],
632
 
                                }
633
598
                        else:
634
599
                            merged_ids[change[2]] = [change[3].revision]
635
 
                            parent_entries[change[2]] = {change[3].revision:change[3]}
 
600
                        parent_entries[change[2]] = {change[3].revision:change[3]}
636
601
                    else:
637
602
                        merged_ids[change[2]].append(change[3].revision)
638
603
                        parent_entries[change[2]][change[3].revision] = change[3]
663
628
            # inv delta  change: (file_id, (path_in_source, path_in_target),
664
629
            #   changed_content, versioned, parent, name, kind,
665
630
            #   executable)
666
 
            try:
667
 
                basis_entry = basis_inv[file_id]
668
 
            except errors.NoSuchId:
669
 
                # a change from basis->some_parents but file_id isn't in basis
670
 
                # so was new in the merge, which means it must have changed
671
 
                # from basis -> current, and as it hasn't the add was reverted
672
 
                # by the user. So we discard this change.
673
 
                pass
674
 
            else:
675
 
                change = (file_id,
676
 
                    (basis_inv.id2path(file_id), tree.id2path(file_id)),
677
 
                    False, (True, True),
678
 
                    (basis_entry.parent_id, basis_entry.parent_id),
679
 
                    (basis_entry.name, basis_entry.name),
680
 
                    (basis_entry.kind, basis_entry.kind),
681
 
                    (basis_entry.executable, basis_entry.executable))
682
 
                changes[file_id] = (change, merged_ids[file_id])
 
631
            basis_entry = basis_inv[file_id]
 
632
            change = (file_id,
 
633
                (basis_inv.id2path(file_id), tree.id2path(file_id)),
 
634
                False, (True, True),
 
635
                (basis_entry.parent_id, basis_entry.parent_id),
 
636
                (basis_entry.name, basis_entry.name),
 
637
                (basis_entry.kind, basis_entry.kind),
 
638
                (basis_entry.executable, basis_entry.executable))
 
639
            changes[file_id] = (change, merged_ids[file_id])
683
640
        # changes contains tuples with the change and a set of inventory
684
641
        # candidates for the file.
685
642
        # inv delta is:
751
708
                        entry.executable = True
752
709
                    else:
753
710
                        entry.executable = False
754
 
                    if (carry_over_possible and
 
711
                    if (carry_over_possible and 
755
712
                        parent_entry.executable == entry.executable):
756
713
                            # Check the file length, content hash after reading
757
714
                            # the file.
760
717
                        nostore_sha = None
761
718
                    file_obj, stat_value = tree.get_file_with_stat(file_id, change[1][1])
762
719
                    try:
763
 
                        text = file_obj.read()
 
720
                        lines = file_obj.readlines()
764
721
                    finally:
765
722
                        file_obj.close()
766
723
                    try:
767
724
                        entry.text_sha1, entry.text_size = self._add_text_to_weave(
768
 
                            file_id, text, heads, nostore_sha)
769
 
                        yield file_id, change[1][1], (entry.text_sha1, stat_value)
 
725
                            file_id, lines, heads, nostore_sha)
770
726
                    except errors.ExistingContent:
771
727
                        # No content change against a carry_over parent
772
 
                        # Perhaps this should also yield a fs hash update?
773
728
                        carried_over = True
774
729
                        entry.text_size = parent_entry.text_size
775
730
                        entry.text_sha1 = parent_entry.text_sha1
778
733
                    entry.symlink_target = tree.get_symlink_target(file_id)
779
734
                    if (carry_over_possible and
780
735
                        parent_entry.symlink_target == entry.symlink_target):
781
 
                        carried_over = True
 
736
                            carried_over = True
782
737
                    else:
783
 
                        self._add_text_to_weave(change[0], '', heads, None)
 
738
                        self._add_text_to_weave(change[0], [], heads, None)
784
739
                elif kind == 'directory':
785
740
                    if carry_over_possible:
786
741
                        carried_over = True
788
743
                        # Nothing to set on the entry.
789
744
                        # XXX: split into the Root and nonRoot versions.
790
745
                        if change[1][1] != '' or self.repository.supports_rich_root():
791
 
                            self._add_text_to_weave(change[0], '', heads, None)
 
746
                            self._add_text_to_weave(change[0], [], heads, None)
792
747
                elif kind == 'tree-reference':
793
 
                    if not self.repository._format.supports_tree_reference:
794
 
                        # This isn't quite sane as an error, but we shouldn't
795
 
                        # ever see this code path in practice: tree's don't
796
 
                        # permit references when the repo doesn't support tree
797
 
                        # references.
798
 
                        raise errors.UnsupportedOperation(tree.add_reference,
799
 
                            self.repository)
800
 
                    reference_revision = tree.get_reference_revision(change[0])
801
 
                    entry.reference_revision = reference_revision
802
 
                    if (carry_over_possible and
803
 
                        parent_entry.reference_revision == reference_revision):
804
 
                        carried_over = True
805
 
                    else:
806
 
                        self._add_text_to_weave(change[0], '', heads, None)
 
748
                    raise AssertionError('unknown kind %r' % kind)
807
749
                else:
808
750
                    raise AssertionError('unknown kind %r' % kind)
809
751
                if not carried_over:
818
760
                seen_root = True
819
761
        self.new_inventory = None
820
762
        if len(inv_delta):
821
 
            # This should perhaps be guarded by a check that the basis we
822
 
            # commit against is the basis for the commit and if not do a delta
823
 
            # against the basis.
824
763
            self._any_changes = True
825
764
        if not seen_root:
826
765
            # housekeeping root entry changes do not affect no-change commits.
827
766
            self._require_root_change(tree)
828
767
        self.basis_delta_revision = basis_revision_id
829
768
 
830
 
    def _add_text_to_weave(self, file_id, new_text, parents, nostore_sha):
831
 
        parent_keys = tuple([(file_id, parent) for parent in parents])
832
 
        return self.repository.texts._add_text(
833
 
            (file_id, self._new_revision_id), parent_keys, new_text,
834
 
            nostore_sha=nostore_sha, random_id=self.random_revid)[0:2]
 
769
    def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):
 
770
        # Note: as we read the content directly from the tree, we know its not
 
771
        # been turned into unicode or badly split - but a broken tree
 
772
        # implementation could give us bad output from readlines() so this is
 
773
        # not a guarantee of safety. What would be better is always checking
 
774
        # the content during test suite execution. RBC 20070912
 
775
        parent_keys = tuple((file_id, parent) for parent in parents)
 
776
        return self.repository.texts.add_lines(
 
777
            (file_id, self._new_revision_id), parent_keys, new_lines,
 
778
            nostore_sha=nostore_sha, random_id=self.random_revid,
 
779
            check_content=False)[0:2]
835
780
 
836
781
 
837
782
class RootCommitBuilder(CommitBuilder):
863
808
######################################################################
864
809
# Repositories
865
810
 
866
 
 
867
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
811
class Repository(object):
868
812
    """Repository holding history for one or more branches.
869
813
 
870
814
    The repository holds and retrieves historical information including
872
816
    which views a particular line of development through that history.
873
817
 
874
818
    The Repository builds on top of some byte storage facilies (the revisions,
875
 
    signatures, inventories, texts and chk_bytes attributes) and a Transport,
876
 
    which respectively provide byte storage and a means to access the (possibly
 
819
    signatures, inventories and texts attributes) and a Transport, which
 
820
    respectively provide byte storage and a means to access the (possibly
877
821
    remote) disk.
878
822
 
879
823
    The byte storage facilities are addressed via tuples, which we refer to
880
824
    as 'keys' throughout the code base. Revision_keys, inventory_keys and
881
825
    signature_keys are all 1-tuples: (revision_id,). text_keys are two-tuples:
882
 
    (file_id, revision_id). chk_bytes uses CHK keys - a 1-tuple with a single
883
 
    byte string made up of a hash identifier and a hash value.
884
 
    We use this interface because it allows low friction with the underlying
885
 
    code that implements disk indices, network encoding and other parts of
886
 
    bzrlib.
 
826
    (file_id, revision_id). We use this interface because it allows low
 
827
    friction with the underlying code that implements disk indices, network
 
828
    encoding and other parts of bzrlib.
887
829
 
888
830
    :ivar revisions: A bzrlib.versionedfile.VersionedFiles instance containing
889
831
        the serialised revisions for the repository. This can be used to obtain
908
850
        The result of trying to insert data into the repository via this store
909
851
        is undefined: it should be considered read-only except for implementors
910
852
        of repositories.
911
 
    :ivar chk_bytes: A bzrlib.versionedfile.VersionedFiles instance containing
912
 
        any data the repository chooses to store or have indexed by its hash.
913
 
        The result of trying to insert data into the repository via this store
914
 
        is undefined: it should be considered read-only except for implementors
915
 
        of repositories.
916
853
    :ivar _transport: Transport for file access to repository, typically
917
854
        pointing to .bzr/repository.
918
855
    """
939
876
        """
940
877
        if self._write_group is not self.get_transaction():
941
878
            # has an unlock or relock occured ?
942
 
            if suppress_errors:
943
 
                mutter(
944
 
                '(suppressed) mismatched lock context and write group. %r, %r',
945
 
                self._write_group, self.get_transaction())
946
 
                return
947
 
            raise errors.BzrError(
948
 
                'mismatched lock context and write group. %r, %r' %
949
 
                (self._write_group, self.get_transaction()))
 
879
            raise errors.BzrError('mismatched lock context and write group.')
950
880
        try:
951
881
            self._abort_write_group()
952
882
        except Exception, exc:
978
908
        """
979
909
        if not self._format.supports_external_lookups:
980
910
            raise errors.UnstackableRepositoryFormat(self._format, self.base)
981
 
        if self.is_locked():
982
 
            # This repository will call fallback.unlock() when we transition to
983
 
            # the unlocked state, so we make sure to increment the lock count
984
 
            repository.lock_read()
985
911
        self._check_fallback_repository(repository)
986
912
        self._fallback_repositories.append(repository)
987
913
        self.texts.add_fallback_versioned_files(repository.texts)
988
914
        self.inventories.add_fallback_versioned_files(repository.inventories)
989
915
        self.revisions.add_fallback_versioned_files(repository.revisions)
990
916
        self.signatures.add_fallback_versioned_files(repository.signatures)
991
 
        if self.chk_bytes is not None:
992
 
            self.chk_bytes.add_fallback_versioned_files(repository.chk_bytes)
993
917
 
994
918
    def _check_fallback_repository(self, repository):
995
919
        """Check that this repository can fallback to repository safely.
1019
943
                % (inv.revision_id, revision_id))
1020
944
        if inv.root is None:
1021
945
            raise AssertionError()
1022
 
        return self._add_inventory_checked(revision_id, inv, parents)
1023
 
 
1024
 
    def _add_inventory_checked(self, revision_id, inv, parents):
1025
 
        """Add inv to the repository after checking the inputs.
1026
 
 
1027
 
        This function can be overridden to allow different inventory styles.
1028
 
 
1029
 
        :seealso: add_inventory, for the contract.
1030
 
        """
1031
 
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
946
        inv_lines = self._serialise_inventory_to_lines(inv)
1032
947
        return self._inventory_add_lines(revision_id, parents,
1033
948
            inv_lines, check_content=False)
1034
949
 
1035
950
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1036
 
                               parents, basis_inv=None, propagate_caches=False):
 
951
                               parents):
1037
952
        """Add a new inventory expressed as a delta against another revision.
1038
953
 
1039
 
        See the inventory developers documentation for the theory behind
1040
 
        inventory deltas.
1041
 
 
1042
954
        :param basis_revision_id: The inventory id the delta was created
1043
955
            against. (This does not have to be a direct parent.)
1044
956
        :param delta: The inventory delta (see Inventory.apply_delta for
1050
962
            for repositories that depend on the inventory graph for revision
1051
963
            graph access, as well as for those that pun ancestry with delta
1052
964
            compression.
1053
 
        :param basis_inv: The basis inventory if it is already known,
1054
 
            otherwise None.
1055
 
        :param propagate_caches: If True, the caches for this inventory are
1056
 
          copied to and updated for the result if possible.
1057
965
 
1058
966
        :returns: (validator, new_inv)
1059
967
            The validator(which is a sha1 digest, though what is sha'd is
1070
978
            # inventory implementations may support: A better idiom would be to
1071
979
            # return a new inventory, but as there is no revision tree cache in
1072
980
            # repository this is safe for now - RBC 20081013
1073
 
            if basis_inv is None:
1074
 
                basis_inv = basis_tree.inventory
 
981
            basis_inv = basis_tree.inventory
1075
982
            basis_inv.apply_delta(delta)
1076
983
            basis_inv.revision_id = new_revision_id
1077
984
            return (self.add_inventory(new_revision_id, basis_inv, parents),
1083
990
        check_content=True):
1084
991
        """Store lines in inv_vf and return the sha1 of the inventory."""
1085
992
        parents = [(parent,) for parent in parents]
1086
 
        result = self.inventories.add_lines((revision_id,), parents, lines,
 
993
        return self.inventories.add_lines((revision_id,), parents, lines,
1087
994
            check_content=check_content)[0]
1088
 
        self.inventories._access.flush()
1089
 
        return result
1090
995
 
1091
996
    def add_revision(self, revision_id, rev, inv=None, config=None):
1092
997
        """Add rev to the revision store as revision_id.
1168
1073
        # The old API returned a list, should this actually be a set?
1169
1074
        return parent_map.keys()
1170
1075
 
1171
 
    def _check_inventories(self, checker):
1172
 
        """Check the inventories found from the revision scan.
1173
 
        
1174
 
        This is responsible for verifying the sha1 of inventories and
1175
 
        creating a pending_keys set that covers data referenced by inventories.
1176
 
        """
1177
 
        bar = ui.ui_factory.nested_progress_bar()
1178
 
        try:
1179
 
            self._do_check_inventories(checker, bar)
1180
 
        finally:
1181
 
            bar.finished()
1182
 
 
1183
 
    def _do_check_inventories(self, checker, bar):
1184
 
        """Helper for _check_inventories."""
1185
 
        revno = 0
1186
 
        keys = {'chk_bytes':set(), 'inventories':set(), 'texts':set()}
1187
 
        kinds = ['chk_bytes', 'texts']
1188
 
        count = len(checker.pending_keys)
1189
 
        bar.update("inventories", 0, 2)
1190
 
        current_keys = checker.pending_keys
1191
 
        checker.pending_keys = {}
1192
 
        # Accumulate current checks.
1193
 
        for key in current_keys:
1194
 
            if key[0] != 'inventories' and key[0] not in kinds:
1195
 
                checker._report_items.append('unknown key type %r' % (key,))
1196
 
            keys[key[0]].add(key[1:])
1197
 
        if keys['inventories']:
1198
 
            # NB: output order *should* be roughly sorted - topo or
1199
 
            # inverse topo depending on repository - either way decent
1200
 
            # to just delta against. However, pre-CHK formats didn't
1201
 
            # try to optimise inventory layout on disk. As such the
1202
 
            # pre-CHK code path does not use inventory deltas.
1203
 
            last_object = None
1204
 
            for record in self.inventories.check(keys=keys['inventories']):
1205
 
                if record.storage_kind == 'absent':
1206
 
                    checker._report_items.append(
1207
 
                        'Missing inventory {%s}' % (record.key,))
1208
 
                else:
1209
 
                    last_object = self._check_record('inventories', record,
1210
 
                        checker, last_object,
1211
 
                        current_keys[('inventories',) + record.key])
1212
 
            del keys['inventories']
1213
 
        else:
1214
 
            return
1215
 
        bar.update("texts", 1)
1216
 
        while (checker.pending_keys or keys['chk_bytes']
1217
 
            or keys['texts']):
1218
 
            # Something to check.
1219
 
            current_keys = checker.pending_keys
1220
 
            checker.pending_keys = {}
1221
 
            # Accumulate current checks.
1222
 
            for key in current_keys:
1223
 
                if key[0] not in kinds:
1224
 
                    checker._report_items.append('unknown key type %r' % (key,))
1225
 
                keys[key[0]].add(key[1:])
1226
 
            # Check the outermost kind only - inventories || chk_bytes || texts
1227
 
            for kind in kinds:
1228
 
                if keys[kind]:
1229
 
                    last_object = None
1230
 
                    for record in getattr(self, kind).check(keys=keys[kind]):
1231
 
                        if record.storage_kind == 'absent':
1232
 
                            checker._report_items.append(
1233
 
                                'Missing %s {%s}' % (kind, record.key,))
1234
 
                        else:
1235
 
                            last_object = self._check_record(kind, record,
1236
 
                                checker, last_object, current_keys[(kind,) + record.key])
1237
 
                    keys[kind] = set()
1238
 
                    break
1239
 
 
1240
 
    def _check_record(self, kind, record, checker, last_object, item_data):
1241
 
        """Check a single text from this repository."""
1242
 
        if kind == 'inventories':
1243
 
            rev_id = record.key[0]
1244
 
            inv = self._deserialise_inventory(rev_id,
1245
 
                record.get_bytes_as('fulltext'))
1246
 
            if last_object is not None:
1247
 
                delta = inv._make_delta(last_object)
1248
 
                for old_path, path, file_id, ie in delta:
1249
 
                    if ie is None:
1250
 
                        continue
1251
 
                    ie.check(checker, rev_id, inv)
1252
 
            else:
1253
 
                for path, ie in inv.iter_entries():
1254
 
                    ie.check(checker, rev_id, inv)
1255
 
            if self._format.fast_deltas:
1256
 
                return inv
1257
 
        elif kind == 'chk_bytes':
1258
 
            # No code written to check chk_bytes for this repo format.
1259
 
            checker._report_items.append(
1260
 
                'unsupported key type chk_bytes for %s' % (record.key,))
1261
 
        elif kind == 'texts':
1262
 
            self._check_text(record, checker, item_data)
1263
 
        else:
1264
 
            checker._report_items.append(
1265
 
                'unknown key type %s for %s' % (kind, record.key))
1266
 
 
1267
 
    def _check_text(self, record, checker, item_data):
1268
 
        """Check a single text."""
1269
 
        # Check it is extractable.
1270
 
        # TODO: check length.
1271
 
        if record.storage_kind == 'chunked':
1272
 
            chunks = record.get_bytes_as(record.storage_kind)
1273
 
            sha1 = osutils.sha_strings(chunks)
1274
 
            length = sum(map(len, chunks))
1275
 
        else:
1276
 
            content = record.get_bytes_as('fulltext')
1277
 
            sha1 = osutils.sha_string(content)
1278
 
            length = len(content)
1279
 
        if item_data and sha1 != item_data[1]:
1280
 
            checker._report_items.append(
1281
 
                'sha1 mismatch: %s has sha1 %s expected %s referenced by %s' %
1282
 
                (record.key, sha1, item_data[1], item_data[2]))
1283
 
 
1284
1076
    @staticmethod
1285
1077
    def create(a_bzrdir):
1286
1078
        """Construct the current default format repository in a_bzrdir."""
1291
1083
 
1292
1084
        :param _format: The format of the repository on disk.
1293
1085
        :param a_bzrdir: The BzrDir of the repository.
 
1086
 
 
1087
        In the future we will have a single api for all stores for
 
1088
        getting file texts, inventories and revisions, then
 
1089
        this construct will accept instances of those things.
1294
1090
        """
1295
 
        # In the future we will have a single api for all stores for
1296
 
        # getting file texts, inventories and revisions, then
1297
 
        # this construct will accept instances of those things.
1298
1091
        super(Repository, self).__init__()
1299
1092
        self._format = _format
1300
1093
        # the following are part of the public API for Repository:
1306
1099
        self._reconcile_does_inventory_gc = True
1307
1100
        self._reconcile_fixes_text_parents = False
1308
1101
        self._reconcile_backsup_inventory = True
 
1102
        # not right yet - should be more semantically clear ?
 
1103
        #
 
1104
        # TODO: make sure to construct the right store classes, etc, depending
 
1105
        # on whether escaping is required.
 
1106
        self._warn_if_deprecated()
1309
1107
        self._write_group = None
1310
1108
        # Additional places to query for data.
1311
1109
        self._fallback_repositories = []
1312
1110
        # An InventoryEntry cache, used during deserialization
1313
1111
        self._inventory_entry_cache = fifo_cache.FIFOCache(10*1024)
1314
 
        # Is it safe to return inventory entries directly from the entry cache,
1315
 
        # rather copying them?
1316
 
        self._safe_to_return_from_cache = False
1317
 
 
1318
 
    @property
1319
 
    def user_transport(self):
1320
 
        return self.bzrdir.user_transport
1321
 
 
1322
 
    @property
1323
 
    def control_transport(self):
1324
 
        return self._transport
1325
1112
 
1326
1113
    def __repr__(self):
1327
 
        if self._fallback_repositories:
1328
 
            return '%s(%r, fallback_repositories=%r)' % (
1329
 
                self.__class__.__name__,
1330
 
                self.base,
1331
 
                self._fallback_repositories)
1332
 
        else:
1333
 
            return '%s(%r)' % (self.__class__.__name__,
1334
 
                               self.base)
1335
 
 
1336
 
    def _has_same_fallbacks(self, other_repo):
1337
 
        """Returns true if the repositories have the same fallbacks."""
1338
 
        my_fb = self._fallback_repositories
1339
 
        other_fb = other_repo._fallback_repositories
1340
 
        if len(my_fb) != len(other_fb):
1341
 
            return False
1342
 
        for f, g in zip(my_fb, other_fb):
1343
 
            if not f.has_same_location(g):
1344
 
                return False
1345
 
        return True
 
1114
        return '%s(%r)' % (self.__class__.__name__,
 
1115
                           self.base)
1346
1116
 
1347
1117
    def has_same_location(self, other):
1348
1118
        """Returns a boolean indicating if this repository is at the same
1393
1163
        """
1394
1164
        locked = self.is_locked()
1395
1165
        result = self.control_files.lock_write(token=token)
 
1166
        for repo in self._fallback_repositories:
 
1167
            # Writes don't affect fallback repos
 
1168
            repo.lock_read()
1396
1169
        if not locked:
1397
 
            self._warn_if_deprecated()
1398
 
            self._note_lock('w')
1399
 
            for repo in self._fallback_repositories:
1400
 
                # Writes don't affect fallback repos
1401
 
                repo.lock_read()
1402
1170
            self._refresh_data()
1403
1171
        return result
1404
1172
 
1405
1173
    def lock_read(self):
1406
1174
        locked = self.is_locked()
1407
1175
        self.control_files.lock_read()
 
1176
        for repo in self._fallback_repositories:
 
1177
            repo.lock_read()
1408
1178
        if not locked:
1409
 
            self._warn_if_deprecated()
1410
 
            self._note_lock('r')
1411
 
            for repo in self._fallback_repositories:
1412
 
                repo.lock_read()
1413
1179
            self._refresh_data()
1414
1180
 
1415
1181
    def get_physical_lock_status(self):
1476
1242
 
1477
1243
        # now gather global repository information
1478
1244
        # XXX: This is available for many repos regardless of listability.
1479
 
        if self.user_transport.listable():
 
1245
        if self.bzrdir.root_transport.listable():
1480
1246
            # XXX: do we want to __define len__() ?
1481
1247
            # Maybe the versionedfiles object should provide a different
1482
1248
            # method to get the number of keys.
1492
1258
        :param using: If True, list only branches using this repository.
1493
1259
        """
1494
1260
        if using and not self.is_shared():
1495
 
            return self.bzrdir.list_branches()
 
1261
            try:
 
1262
                return [self.bzrdir.open_branch()]
 
1263
            except errors.NotBranchError:
 
1264
                return []
1496
1265
        class Evaluator(object):
1497
1266
 
1498
1267
            def __init__(self):
1507
1276
                    except errors.NoRepositoryPresent:
1508
1277
                        pass
1509
1278
                    else:
1510
 
                        return False, ([], repository)
 
1279
                        return False, (None, repository)
1511
1280
                self.first_call = False
1512
 
                value = (bzrdir.list_branches(), None)
 
1281
                try:
 
1282
                    value = (bzrdir.open_branch(), None)
 
1283
                except errors.NotBranchError:
 
1284
                    value = (None, None)
1513
1285
                return True, value
1514
1286
 
1515
 
        ret = []
1516
 
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
1517
 
                self.user_transport, evaluate=Evaluator()):
1518
 
            if branches is not None:
1519
 
                ret.extend(branches)
 
1287
        branches = []
 
1288
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
1289
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
1290
            if branch is not None:
 
1291
                branches.append(branch)
1520
1292
            if not using and repository is not None:
1521
 
                ret.extend(repository.find_branches())
1522
 
        return ret
 
1293
                branches.extend(repository.find_branches())
 
1294
        return branches
1523
1295
 
1524
1296
    @needs_read_lock
1525
1297
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1554
1326
        """Commit the contents accrued within the current write group.
1555
1327
 
1556
1328
        :seealso: start_write_group.
1557
 
        
1558
 
        :return: it may return an opaque hint that can be passed to 'pack'.
1559
1329
        """
1560
1330
        if self._write_group is not self.get_transaction():
1561
1331
            # has an unlock or relock occured ?
1562
1332
            raise errors.BzrError('mismatched lock context %r and '
1563
1333
                'write group %r.' %
1564
1334
                (self.get_transaction(), self._write_group))
1565
 
        result = self._commit_write_group()
 
1335
        self._commit_write_group()
1566
1336
        self._write_group = None
1567
 
        return result
1568
1337
 
1569
1338
    def _commit_write_group(self):
1570
1339
        """Template method for per-repository write group cleanup.
1578
1347
    def suspend_write_group(self):
1579
1348
        raise errors.UnsuspendableWriteGroup(self)
1580
1349
 
1581
 
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
1582
 
        """Return the keys of missing inventory parents for revisions added in
1583
 
        this write group.
1584
 
 
1585
 
        A revision is not complete if the inventory delta for that revision
1586
 
        cannot be calculated.  Therefore if the parent inventories of a
1587
 
        revision are not present, the revision is incomplete, and e.g. cannot
1588
 
        be streamed by a smart server.  This method finds missing inventory
1589
 
        parents for revisions added in this write group.
1590
 
        """
1591
 
        if not self._format.supports_external_lookups:
1592
 
            # This is only an issue for stacked repositories
1593
 
            return set()
1594
 
        if not self.is_in_write_group():
1595
 
            raise AssertionError('not in a write group')
1596
 
 
1597
 
        # XXX: We assume that every added revision already has its
1598
 
        # corresponding inventory, so we only check for parent inventories that
1599
 
        # might be missing, rather than all inventories.
1600
 
        parents = set(self.revisions._index.get_missing_parents())
1601
 
        parents.discard(_mod_revision.NULL_REVISION)
1602
 
        unstacked_inventories = self.inventories._index
1603
 
        present_inventories = unstacked_inventories.get_parent_map(
1604
 
            key[-1:] for key in parents)
1605
 
        parents.difference_update(present_inventories)
1606
 
        if len(parents) == 0:
1607
 
            # No missing parent inventories.
1608
 
            return set()
1609
 
        if not check_for_missing_texts:
1610
 
            return set(('inventories', rev_id) for (rev_id,) in parents)
1611
 
        # Ok, now we have a list of missing inventories.  But these only matter
1612
 
        # if the inventories that reference them are missing some texts they
1613
 
        # appear to introduce.
1614
 
        # XXX: Texts referenced by all added inventories need to be present,
1615
 
        # but at the moment we're only checking for texts referenced by
1616
 
        # inventories at the graph's edge.
1617
 
        key_deps = self.revisions._index._key_dependencies
1618
 
        key_deps.satisfy_refs_for_keys(present_inventories)
1619
 
        referrers = frozenset(r[0] for r in key_deps.get_referrers())
1620
 
        file_ids = self.fileids_altered_by_revision_ids(referrers)
1621
 
        missing_texts = set()
1622
 
        for file_id, version_ids in file_ids.iteritems():
1623
 
            missing_texts.update(
1624
 
                (file_id, version_id) for version_id in version_ids)
1625
 
        present_texts = self.texts.get_parent_map(missing_texts)
1626
 
        missing_texts.difference_update(present_texts)
1627
 
        if not missing_texts:
1628
 
            # No texts are missing, so all revisions and their deltas are
1629
 
            # reconstructable.
1630
 
            return set()
1631
 
        # Alternatively the text versions could be returned as the missing
1632
 
        # keys, but this is likely to be less data.
1633
 
        missing_keys = set(('inventories', rev_id) for (rev_id,) in parents)
1634
 
        return missing_keys
1635
 
 
1636
1350
    def refresh_data(self):
1637
1351
        """Re-read any data needed to to synchronise with disk.
1638
1352
 
1687
1401
            raise errors.InternalBzrError(
1688
1402
                "May not fetch while in a write group.")
1689
1403
        # fast path same-url fetch operations
1690
 
        # TODO: lift out to somewhere common with RemoteRepository
1691
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401646>
1692
 
        if (self.has_same_location(source)
1693
 
            and fetch_spec is None
1694
 
            and self._has_same_fallbacks(source)):
 
1404
        if self.has_same_location(source) and fetch_spec is None:
1695
1405
            # check that last_revision is in 'from' and then return a
1696
1406
            # no-operation.
1697
1407
            if (revision_id is not None and
1722
1432
        :param revprops: Optional dictionary of revision properties.
1723
1433
        :param revision_id: Optional revision id.
1724
1434
        """
1725
 
        if self._fallback_repositories:
1726
 
            raise errors.BzrError("Cannot commit from a lightweight checkout "
1727
 
                "to a stacked branch. See "
1728
 
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
1729
1435
        result = self._commit_builder_class(self, parents, config,
1730
1436
            timestamp, timezone, committer, revprops, revision_id)
1731
1437
        self.start_write_group()
1732
1438
        return result
1733
1439
 
1734
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1735
1440
    def unlock(self):
1736
1441
        if (self.control_files._lock_count == 1 and
1737
1442
            self.control_files._lock_mode == 'w'):
1743
1448
        self.control_files.unlock()
1744
1449
        if self.control_files._lock_count == 0:
1745
1450
            self._inventory_entry_cache.clear()
1746
 
            for repo in self._fallback_repositories:
1747
 
                repo.unlock()
 
1451
        for repo in self._fallback_repositories:
 
1452
            repo.unlock()
1748
1453
 
1749
1454
    @needs_read_lock
1750
1455
    def clone(self, a_bzrdir, revision_id=None):
1859
1564
 
1860
1565
    @needs_read_lock
1861
1566
    def get_revisions(self, revision_ids):
1862
 
        """Get many revisions at once.
1863
 
        
1864
 
        Repositories that need to check data on every revision read should 
1865
 
        subclass this method.
1866
 
        """
 
1567
        """Get many revisions at once."""
1867
1568
        return self._get_revisions(revision_ids)
1868
1569
 
1869
1570
    @needs_read_lock
1870
1571
    def _get_revisions(self, revision_ids):
1871
1572
        """Core work logic to get many revisions without sanity checks."""
 
1573
        for rev_id in revision_ids:
 
1574
            if not rev_id or not isinstance(rev_id, basestring):
 
1575
                raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
 
1576
        keys = [(key,) for key in revision_ids]
 
1577
        stream = self.revisions.get_record_stream(keys, 'unordered', True)
1872
1578
        revs = {}
1873
 
        for revid, rev in self._iter_revisions(revision_ids):
1874
 
            if rev is None:
1875
 
                raise errors.NoSuchRevision(self, revid)
1876
 
            revs[revid] = rev
 
1579
        for record in stream:
 
1580
            if record.storage_kind == 'absent':
 
1581
                raise errors.NoSuchRevision(self, record.key[0])
 
1582
            text = record.get_bytes_as('fulltext')
 
1583
            rev = self._serializer.read_revision_from_string(text)
 
1584
            revs[record.key[0]] = rev
1877
1585
        return [revs[revid] for revid in revision_ids]
1878
1586
 
1879
 
    def _iter_revisions(self, revision_ids):
1880
 
        """Iterate over revision objects.
1881
 
 
1882
 
        :param revision_ids: An iterable of revisions to examine. None may be
1883
 
            passed to request all revisions known to the repository. Note that
1884
 
            not all repositories can find unreferenced revisions; for those
1885
 
            repositories only referenced ones will be returned.
1886
 
        :return: An iterator of (revid, revision) tuples. Absent revisions (
1887
 
            those asked for but not available) are returned as (revid, None).
1888
 
        """
1889
 
        if revision_ids is None:
1890
 
            revision_ids = self.all_revision_ids()
1891
 
        else:
1892
 
            for rev_id in revision_ids:
1893
 
                if not rev_id or not isinstance(rev_id, basestring):
1894
 
                    raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
1895
 
        keys = [(key,) for key in revision_ids]
1896
 
        stream = self.revisions.get_record_stream(keys, 'unordered', True)
1897
 
        for record in stream:
1898
 
            revid = record.key[0]
1899
 
            if record.storage_kind == 'absent':
1900
 
                yield (revid, None)
1901
 
            else:
1902
 
                text = record.get_bytes_as('fulltext')
1903
 
                rev = self._serializer.read_revision_from_string(text)
1904
 
                yield (revid, rev)
 
1587
    @needs_read_lock
 
1588
    def get_revision_xml(self, revision_id):
 
1589
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1590
        #       would have already do it.
 
1591
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1592
        rev = self.get_revision(revision_id)
 
1593
        rev_tmp = cStringIO.StringIO()
 
1594
        # the current serializer..
 
1595
        self._serializer.write_revision(rev, rev_tmp)
 
1596
        rev_tmp.seek(0)
 
1597
        return rev_tmp.getvalue()
1905
1598
 
1906
1599
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1907
1600
        """Produce a generator of revision deltas.
2085
1778
                    yield line, revid
2086
1779
 
2087
1780
    def _find_file_ids_from_xml_inventory_lines(self, line_iterator,
2088
 
        revision_keys):
 
1781
        revision_ids):
2089
1782
        """Helper routine for fileids_altered_by_revision_ids.
2090
1783
 
2091
1784
        This performs the translation of xml lines to revision ids.
2092
1785
 
2093
1786
        :param line_iterator: An iterator of lines, origin_version_id
2094
 
        :param revision_keys: The revision ids to filter for. This should be a
 
1787
        :param revision_ids: The revision ids to filter for. This should be a
2095
1788
            set or other type which supports efficient __contains__ lookups, as
2096
 
            the revision key from each parsed line will be looked up in the
2097
 
            revision_keys filter.
 
1789
            the revision id from each parsed line will be looked up in the
 
1790
            revision_ids filter.
2098
1791
        :return: a dictionary mapping altered file-ids to an iterable of
2099
1792
        revision_ids. Each altered file-ids has the exact revision_ids that
2100
1793
        altered it listed explicitly.
2101
1794
        """
2102
1795
        seen = set(self._find_text_key_references_from_xml_inventory_lines(
2103
1796
                line_iterator).iterkeys())
2104
 
        parent_keys = self._find_parent_keys_of_revisions(revision_keys)
 
1797
        # Note that revision_ids are revision keys.
 
1798
        parent_maps = self.revisions.get_parent_map(revision_ids)
 
1799
        parents = set()
 
1800
        map(parents.update, parent_maps.itervalues())
 
1801
        parents.difference_update(revision_ids)
2105
1802
        parent_seen = set(self._find_text_key_references_from_xml_inventory_lines(
2106
 
            self._inventory_xml_lines_for_keys(parent_keys)))
 
1803
            self._inventory_xml_lines_for_keys(parents)))
2107
1804
        new_keys = seen - parent_seen
2108
1805
        result = {}
2109
1806
        setdefault = result.setdefault
2111
1808
            setdefault(key[0], set()).add(key[-1])
2112
1809
        return result
2113
1810
 
2114
 
    def _find_parent_ids_of_revisions(self, revision_ids):
2115
 
        """Find all parent ids that are mentioned in the revision graph.
2116
 
 
2117
 
        :return: set of revisions that are parents of revision_ids which are
2118
 
            not part of revision_ids themselves
2119
 
        """
2120
 
        parent_map = self.get_parent_map(revision_ids)
2121
 
        parent_ids = set()
2122
 
        map(parent_ids.update, parent_map.itervalues())
2123
 
        parent_ids.difference_update(revision_ids)
2124
 
        parent_ids.discard(_mod_revision.NULL_REVISION)
2125
 
        return parent_ids
2126
 
 
2127
 
    def _find_parent_keys_of_revisions(self, revision_keys):
2128
 
        """Similar to _find_parent_ids_of_revisions, but used with keys.
2129
 
 
2130
 
        :param revision_keys: An iterable of revision_keys.
2131
 
        :return: The parents of all revision_keys that are not already in
2132
 
            revision_keys
2133
 
        """
2134
 
        parent_map = self.revisions.get_parent_map(revision_keys)
2135
 
        parent_keys = set()
2136
 
        map(parent_keys.update, parent_map.itervalues())
2137
 
        parent_keys.difference_update(revision_keys)
2138
 
        parent_keys.discard(_mod_revision.NULL_REVISION)
2139
 
        return parent_keys
2140
 
 
2141
1811
    def fileids_altered_by_revision_ids(self, revision_ids, _inv_weave=None):
2142
1812
        """Find the file ids and versions affected by revisions.
2143
1813
 
2150
1820
        """
2151
1821
        selected_keys = set((revid,) for revid in revision_ids)
2152
1822
        w = _inv_weave or self.inventories
2153
 
        return self._find_file_ids_from_xml_inventory_lines(
2154
 
            w.iter_lines_added_or_present_in_keys(
2155
 
                selected_keys, pb=None),
2156
 
            selected_keys)
 
1823
        pb = ui.ui_factory.nested_progress_bar()
 
1824
        try:
 
1825
            return self._find_file_ids_from_xml_inventory_lines(
 
1826
                w.iter_lines_added_or_present_in_keys(
 
1827
                    selected_keys, pb=pb),
 
1828
                selected_keys)
 
1829
        finally:
 
1830
            pb.finished()
2157
1831
 
2158
1832
    def iter_files_bytes(self, desired_files):
2159
1833
        """Iterate through file versions.
2241
1915
                batch_size]
2242
1916
            if not to_query:
2243
1917
                break
2244
 
            for revision_id in to_query:
 
1918
            for rev_tree in self.revision_trees(to_query):
 
1919
                revision_id = rev_tree.get_revision_id()
2245
1920
                parent_ids = ancestors[revision_id]
2246
1921
                for text_key in revision_keys[revision_id]:
2247
1922
                    pb.update("Calculating text parents", processed_texts)
2266
1941
                            except KeyError:
2267
1942
                                inv = self.revision_tree(parent_id).inventory
2268
1943
                                inventory_cache[parent_id] = inv
2269
 
                            try:
2270
 
                                parent_entry = inv[text_key[0]]
2271
 
                            except (KeyError, errors.NoSuchId):
2272
 
                                parent_entry = None
 
1944
                            parent_entry = inv._byid.get(text_key[0], None)
2273
1945
                            if parent_entry is not None:
2274
1946
                                parent_text_key = (
2275
1947
                                    text_key[0], parent_entry.revision)
2300
1972
            versions).  knit-kind is one of 'file', 'inventory', 'signatures',
2301
1973
            'revisions'.  file-id is None unless knit-kind is 'file'.
2302
1974
        """
2303
 
        for result in self._find_file_keys_to_fetch(revision_ids, _files_pb):
2304
 
            yield result
2305
 
        del _files_pb
2306
 
        for result in self._find_non_file_keys_to_fetch(revision_ids):
2307
 
            yield result
2308
 
 
2309
 
    def _find_file_keys_to_fetch(self, revision_ids, pb):
2310
1975
        # XXX: it's a bit weird to control the inventory weave caching in this
2311
1976
        # generator.  Ideally the caching would be done in fetch.py I think.  Or
2312
1977
        # maybe this generator should explicitly have the contract that it
2319
1984
        count = 0
2320
1985
        num_file_ids = len(file_ids)
2321
1986
        for file_id, altered_versions in file_ids.iteritems():
2322
 
            if pb is not None:
2323
 
                pb.update("Fetch texts", count, num_file_ids)
 
1987
            if _files_pb is not None:
 
1988
                _files_pb.update("fetch texts", count, num_file_ids)
2324
1989
            count += 1
2325
1990
            yield ("file", file_id, altered_versions)
 
1991
        # We're done with the files_pb.  Note that it finished by the caller,
 
1992
        # just as it was created by the caller.
 
1993
        del _files_pb
2326
1994
 
2327
 
    def _find_non_file_keys_to_fetch(self, revision_ids):
2328
1995
        # inventory
2329
1996
        yield ("inventory", None, revision_ids)
2330
1997
 
2347
2014
        """Get Inventory object by revision id."""
2348
2015
        return self.iter_inventories([revision_id]).next()
2349
2016
 
2350
 
    def iter_inventories(self, revision_ids, ordering=None):
 
2017
    def iter_inventories(self, revision_ids):
2351
2018
        """Get many inventories by revision_ids.
2352
2019
 
2353
2020
        This will buffer some or all of the texts used in constructing the
2355
2022
        time.
2356
2023
 
2357
2024
        :param revision_ids: The expected revision ids of the inventories.
2358
 
        :param ordering: optional ordering, e.g. 'topological'.  If not
2359
 
            specified, the order of revision_ids will be preserved (by
2360
 
            buffering if necessary).
2361
2025
        :return: An iterator of inventories.
2362
2026
        """
2363
2027
        if ((None in revision_ids)
2364
2028
            or (_mod_revision.NULL_REVISION in revision_ids)):
2365
2029
            raise ValueError('cannot get null revision inventory')
2366
 
        return self._iter_inventories(revision_ids, ordering)
 
2030
        return self._iter_inventories(revision_ids)
2367
2031
 
2368
 
    def _iter_inventories(self, revision_ids, ordering):
 
2032
    def _iter_inventories(self, revision_ids):
2369
2033
        """single-document based inventory iteration."""
2370
 
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
2371
 
        for text, revision_id in inv_xmls:
2372
 
            yield self._deserialise_inventory(revision_id, text)
 
2034
        for text, revision_id in self._iter_inventory_xmls(revision_ids):
 
2035
            yield self.deserialise_inventory(revision_id, text)
2373
2036
 
2374
 
    def _iter_inventory_xmls(self, revision_ids, ordering):
2375
 
        if ordering is None:
2376
 
            order_as_requested = True
2377
 
            ordering = 'unordered'
2378
 
        else:
2379
 
            order_as_requested = False
 
2037
    def _iter_inventory_xmls(self, revision_ids):
2380
2038
        keys = [(revision_id,) for revision_id in revision_ids]
2381
 
        if not keys:
2382
 
            return
2383
 
        if order_as_requested:
2384
 
            key_iter = iter(keys)
2385
 
            next_key = key_iter.next()
2386
 
        stream = self.inventories.get_record_stream(keys, ordering, True)
 
2039
        stream = self.inventories.get_record_stream(keys, 'unordered', True)
2387
2040
        text_chunks = {}
2388
2041
        for record in stream:
2389
2042
            if record.storage_kind != 'absent':
2390
 
                chunks = record.get_bytes_as('chunked')
2391
 
                if order_as_requested:
2392
 
                    text_chunks[record.key] = chunks
2393
 
                else:
2394
 
                    yield ''.join(chunks), record.key[-1]
 
2043
                text_chunks[record.key] = record.get_bytes_as('chunked')
2395
2044
            else:
2396
2045
                raise errors.NoSuchRevision(self, record.key)
2397
 
            if order_as_requested:
2398
 
                # Yield as many results as we can while preserving order.
2399
 
                while next_key in text_chunks:
2400
 
                    chunks = text_chunks.pop(next_key)
2401
 
                    yield ''.join(chunks), next_key[-1]
2402
 
                    try:
2403
 
                        next_key = key_iter.next()
2404
 
                    except StopIteration:
2405
 
                        # We still want to fully consume the get_record_stream,
2406
 
                        # just in case it is not actually finished at this point
2407
 
                        next_key = None
2408
 
                        break
 
2046
        for key in keys:
 
2047
            chunks = text_chunks.pop(key)
 
2048
            yield ''.join(chunks), key[-1]
2409
2049
 
2410
 
    def _deserialise_inventory(self, revision_id, xml):
 
2050
    def deserialise_inventory(self, revision_id, xml):
2411
2051
        """Transform the xml into an inventory object.
2412
2052
 
2413
2053
        :param revision_id: The expected revision id of the inventory.
2414
2054
        :param xml: A serialised inventory.
2415
2055
        """
2416
2056
        result = self._serializer.read_inventory_from_string(xml, revision_id,
2417
 
                    entry_cache=self._inventory_entry_cache,
2418
 
                    return_from_cache=self._safe_to_return_from_cache)
 
2057
                    entry_cache=self._inventory_entry_cache)
2419
2058
        if result.revision_id != revision_id:
2420
2059
            raise AssertionError('revision id mismatch %s != %s' % (
2421
2060
                result.revision_id, revision_id))
2422
2061
        return result
2423
2062
 
 
2063
    def serialise_inventory(self, inv):
 
2064
        return self._serializer.write_inventory_to_string(inv)
 
2065
 
 
2066
    def _serialise_inventory_to_lines(self, inv):
 
2067
        return self._serializer.write_inventory_to_lines(inv)
 
2068
 
2424
2069
    def get_serializer_format(self):
2425
2070
        return self._serializer.format_num
2426
2071
 
2427
2072
    @needs_read_lock
2428
 
    def _get_inventory_xml(self, revision_id):
2429
 
        """Get serialized inventory as a string."""
2430
 
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
 
2073
    def get_inventory_xml(self, revision_id):
 
2074
        """Get inventory XML as a file object."""
 
2075
        texts = self._iter_inventory_xmls([revision_id])
2431
2076
        try:
2432
2077
            text, revision_id = texts.next()
2433
2078
        except StopIteration:
2434
2079
            raise errors.HistoryMissing(self, 'inventory', revision_id)
2435
2080
        return text
2436
2081
 
2437
 
    def get_rev_id_for_revno(self, revno, known_pair):
2438
 
        """Return the revision id of a revno, given a later (revno, revid)
2439
 
        pair in the same history.
2440
 
 
2441
 
        :return: if found (True, revid).  If the available history ran out
2442
 
            before reaching the revno, then this returns
2443
 
            (False, (closest_revno, closest_revid)).
 
2082
    @needs_read_lock
 
2083
    def get_inventory_sha1(self, revision_id):
 
2084
        """Return the sha1 hash of the inventory entry
2444
2085
        """
2445
 
        known_revno, known_revid = known_pair
2446
 
        partial_history = [known_revid]
2447
 
        distance_from_known = known_revno - revno
2448
 
        if distance_from_known < 0:
2449
 
            raise ValueError(
2450
 
                'requested revno (%d) is later than given known revno (%d)'
2451
 
                % (revno, known_revno))
2452
 
        try:
2453
 
            _iter_for_revno(
2454
 
                self, partial_history, stop_index=distance_from_known)
2455
 
        except errors.RevisionNotPresent, err:
2456
 
            if err.revision_id == known_revid:
2457
 
                # The start revision (known_revid) wasn't found.
2458
 
                raise
2459
 
            # This is a stacked repository with no fallbacks, or a there's a
2460
 
            # left-hand ghost.  Either way, even though the revision named in
2461
 
            # the error isn't in this repo, we know it's the next step in this
2462
 
            # left-hand history.
2463
 
            partial_history.append(err.revision_id)
2464
 
        if len(partial_history) <= distance_from_known:
2465
 
            # Didn't find enough history to get a revid for the revno.
2466
 
            earliest_revno = known_revno - len(partial_history) + 1
2467
 
            return (False, (earliest_revno, partial_history[-1]))
2468
 
        if len(partial_history) - 1 > distance_from_known:
2469
 
            raise AssertionError('_iter_for_revno returned too much history')
2470
 
        return (True, partial_history[-1])
 
2086
        return self.get_revision(revision_id).inventory_sha1
2471
2087
 
2472
2088
    def iter_reverse_revision_history(self, revision_id):
2473
2089
        """Iterate backwards through revision ids in the lefthand history
2480
2096
        while True:
2481
2097
            if next_id in (None, _mod_revision.NULL_REVISION):
2482
2098
                return
2483
 
            try:
2484
 
                parents = graph.get_parent_map([next_id])[next_id]
2485
 
            except KeyError:
2486
 
                raise errors.RevisionNotPresent(next_id, self)
2487
2099
            yield next_id
 
2100
            # Note: The following line may raise KeyError in the event of
 
2101
            # truncated history. We decided not to have a try:except:raise
 
2102
            # RevisionNotPresent here until we see a use for it, because of the
 
2103
            # cost in an inner loop that is by its very nature O(history).
 
2104
            # Robert Collins 20080326
 
2105
            parents = graph.get_parent_map([next_id])[next_id]
2488
2106
            if len(parents) == 0:
2489
2107
                return
2490
2108
            else:
2491
2109
                next_id = parents[0]
2492
2110
 
 
2111
    @needs_read_lock
 
2112
    def get_revision_inventory(self, revision_id):
 
2113
        """Return inventory of a past revision."""
 
2114
        # TODO: Unify this with get_inventory()
 
2115
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2116
        # must be the same as its revision, so this is trivial.
 
2117
        if revision_id is None:
 
2118
            # This does not make sense: if there is no revision,
 
2119
            # then it is the current tree inventory surely ?!
 
2120
            # and thus get_root_id() is something that looks at the last
 
2121
            # commit on the branch, and the get_root_id is an inventory check.
 
2122
            raise NotImplementedError
 
2123
            # return Inventory(self.get_root_id())
 
2124
        else:
 
2125
            return self.get_inventory(revision_id)
 
2126
 
2493
2127
    def is_shared(self):
2494
2128
        """Return True if this repository is flagged as a shared repository."""
2495
2129
        raise NotImplementedError(self.is_shared)
2529
2163
            return RevisionTree(self, Inventory(root_id=None),
2530
2164
                                _mod_revision.NULL_REVISION)
2531
2165
        else:
2532
 
            inv = self.get_inventory(revision_id)
 
2166
            inv = self.get_revision_inventory(revision_id)
2533
2167
            return RevisionTree(self, inv, revision_id)
2534
2168
 
2535
2169
    def revision_trees(self, revision_ids):
2588
2222
            keys = tsort.topo_sort(parent_map)
2589
2223
        return [None] + list(keys)
2590
2224
 
2591
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2225
    def pack(self):
2592
2226
        """Compress the data within the repository.
2593
2227
 
2594
2228
        This operation only makes sense for some repository types. For other
2597
2231
        This stub method does not require a lock, but subclasses should use
2598
2232
        @needs_write_lock as this is a long running call its reasonable to
2599
2233
        implicitly lock for the user.
2600
 
 
2601
 
        :param hint: If not supplied, the whole repository is packed.
2602
 
            If supplied, the repository may use the hint parameter as a
2603
 
            hint for the parts of the repository to pack. A hint can be
2604
 
            obtained from the result of commit_write_group(). Out of
2605
 
            date hints are simply ignored, because concurrent operations
2606
 
            can obsolete them rapidly.
2607
 
 
2608
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
2609
 
            the pack operation.
2610
2234
        """
2611
2235
 
2612
2236
    def get_transaction(self):
2613
2237
        return self.control_files.get_transaction()
2614
2238
 
2615
2239
    def get_parent_map(self, revision_ids):
2616
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
2240
        """See graph._StackedParentsProvider.get_parent_map"""
2617
2241
        # revisions index works in keys; this just works in revisions
2618
2242
        # therefore wrap and unwrap
2619
2243
        query_keys = []
2628
2252
        for ((revision_id,), parent_keys) in \
2629
2253
                self.revisions.get_parent_map(query_keys).iteritems():
2630
2254
            if parent_keys:
2631
 
                result[revision_id] = tuple([parent_revid
2632
 
                    for (parent_revid,) in parent_keys])
 
2255
                result[revision_id] = tuple(parent_revid
 
2256
                    for (parent_revid,) in parent_keys)
2633
2257
            else:
2634
2258
                result[revision_id] = (_mod_revision.NULL_REVISION,)
2635
2259
        return result
2637
2261
    def _make_parents_provider(self):
2638
2262
        return self
2639
2263
 
2640
 
    @needs_read_lock
2641
 
    def get_known_graph_ancestry(self, revision_ids):
2642
 
        """Return the known graph for a set of revision ids and their ancestors.
2643
 
        """
2644
 
        st = static_tuple.StaticTuple
2645
 
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
2646
 
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
2647
 
        return graph.GraphThunkIdsToKeys(known_graph)
2648
 
 
2649
2264
    def get_graph(self, other_repository=None):
2650
2265
        """Return the graph walker for this repository format"""
2651
2266
        parents_provider = self._make_parents_provider()
2652
2267
        if (other_repository is not None and
2653
2268
            not self.has_same_location(other_repository)):
2654
 
            parents_provider = graph.StackedParentsProvider(
 
2269
            parents_provider = graph._StackedParentsProvider(
2655
2270
                [parents_provider, other_repository._make_parents_provider()])
2656
2271
        return graph.Graph(parents_provider)
2657
2272
 
2658
 
    def _get_versioned_file_checker(self, text_key_references=None,
2659
 
        ancestors=None):
 
2273
    def _get_versioned_file_checker(self, text_key_references=None):
2660
2274
        """Return an object suitable for checking versioned files.
2661
2275
        
2662
2276
        :param text_key_references: if non-None, an already built
2664
2278
            to whether they were referred to by the inventory of the
2665
2279
            revision_id that they contain. If None, this will be
2666
2280
            calculated.
2667
 
        :param ancestors: Optional result from
2668
 
            self.get_graph().get_parent_map(self.all_revision_ids()) if already
2669
 
            available.
2670
2281
        """
2671
2282
        return _VersionedFileChecker(self,
2672
 
            text_key_references=text_key_references, ancestors=ancestors)
 
2283
            text_key_references=text_key_references)
2673
2284
 
2674
2285
    def revision_ids_to_search_result(self, result_set):
2675
2286
        """Convert a set of revision ids to a graph SearchResult."""
2725
2336
        return record.get_bytes_as('fulltext')
2726
2337
 
2727
2338
    @needs_read_lock
2728
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
2339
    def check(self, revision_ids=None):
2729
2340
        """Check consistency of all history of given revision_ids.
2730
2341
 
2731
2342
        Different repository implementations should override _check().
2732
2343
 
2733
2344
        :param revision_ids: A non-empty list of revision_ids whose ancestry
2734
2345
             will be checked.  Typically the last revision_id of a branch.
2735
 
        :param callback_refs: A dict of check-refs to resolve and callback
2736
 
            the check/_check method on the items listed as wanting the ref.
2737
 
            see bzrlib.check.
2738
 
        :param check_repo: If False do not check the repository contents, just 
2739
 
            calculate the data callback_refs requires and call them back.
2740
2346
        """
2741
 
        return self._check(revision_ids, callback_refs=callback_refs,
2742
 
            check_repo=check_repo)
 
2347
        return self._check(revision_ids)
2743
2348
 
2744
 
    def _check(self, revision_ids, callback_refs, check_repo):
2745
 
        result = check.Check(self, check_repo=check_repo)
2746
 
        result.check(callback_refs)
 
2349
    def _check(self, revision_ids):
 
2350
        result = check.Check(self)
 
2351
        result.check()
2747
2352
        return result
2748
2353
 
2749
 
    def _warn_if_deprecated(self, branch=None):
 
2354
    def _warn_if_deprecated(self):
2750
2355
        global _deprecation_warning_done
2751
2356
        if _deprecation_warning_done:
2752
2357
            return
2753
 
        try:
2754
 
            if branch is None:
2755
 
                conf = config.GlobalConfig()
2756
 
            else:
2757
 
                conf = branch.get_config()
2758
 
            if conf.suppress_warning('format_deprecation'):
2759
 
                return
2760
 
            warning("Format %s for %s is deprecated -"
2761
 
                    " please use 'bzr upgrade' to get better performance"
2762
 
                    % (self._format, self.bzrdir.transport.base))
2763
 
        finally:
2764
 
            _deprecation_warning_done = True
 
2358
        _deprecation_warning_done = True
 
2359
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
2360
                % (self._format, self.bzrdir.transport.base))
2765
2361
 
2766
2362
    def supports_rich_root(self):
2767
2363
        return self._format.rich_root_data
2841
2437
    """
2842
2438
    repository.start_write_group()
2843
2439
    try:
2844
 
        inventory_cache = lru_cache.LRUCache(10)
2845
2440
        for n, (revision, revision_tree, signature) in enumerate(iterable):
2846
 
            _install_revision(repository, revision, revision_tree, signature,
2847
 
                inventory_cache)
 
2441
            _install_revision(repository, revision, revision_tree, signature)
2848
2442
            if pb is not None:
2849
2443
                pb.update('Transferring revisions', n + 1, num_revisions)
2850
2444
    except:
2854
2448
        repository.commit_write_group()
2855
2449
 
2856
2450
 
2857
 
def _install_revision(repository, rev, revision_tree, signature,
2858
 
    inventory_cache):
 
2451
def _install_revision(repository, rev, revision_tree, signature):
2859
2452
    """Install all revision data into a repository."""
2860
2453
    present_parents = []
2861
2454
    parent_trees = {}
2898
2491
        repository.texts.add_lines(text_key, text_parents, lines)
2899
2492
    try:
2900
2493
        # install the inventory
2901
 
        if repository._format._commit_inv_deltas and len(rev.parent_ids):
2902
 
            # Cache this inventory
2903
 
            inventory_cache[rev.revision_id] = inv
2904
 
            try:
2905
 
                basis_inv = inventory_cache[rev.parent_ids[0]]
2906
 
            except KeyError:
2907
 
                repository.add_inventory(rev.revision_id, inv, present_parents)
2908
 
            else:
2909
 
                delta = inv._make_delta(basis_inv)
2910
 
                repository.add_inventory_by_delta(rev.parent_ids[0], delta,
2911
 
                    rev.revision_id, present_parents)
2912
 
        else:
2913
 
            repository.add_inventory(rev.revision_id, inv, present_parents)
 
2494
        repository.add_inventory(rev.revision_id, inv, present_parents)
2914
2495
    except errors.RevisionAlreadyPresent:
2915
2496
        pass
2916
2497
    if signature is not None:
3007
2588
 
3008
2589
    Once a format is deprecated, just deprecate the initialize and open
3009
2590
    methods on the format class. Do not deprecate the object, as the
3010
 
    object may be created even when a repository instance hasn't been
 
2591
    object may be created even when a repository instnace hasn't been
3011
2592
    created.
3012
2593
 
3013
2594
    Common instance attributes:
3023
2604
    # Can this repository be given external locations to lookup additional
3024
2605
    # data. Set to True or False in derived classes.
3025
2606
    supports_external_lookups = None
3026
 
    # Does this format support CHK bytestring lookups. Set to True or False in
3027
 
    # derived classes.
3028
 
    supports_chks = None
3029
 
    # Should commit add an inventory, or an inventory delta to the repository.
3030
 
    _commit_inv_deltas = True
3031
2607
    # What order should fetch operations request streams in?
3032
2608
    # The default is unordered as that is the cheapest for an origin to
3033
2609
    # provide.
3043
2619
    # Does this format have < O(tree_size) delta generation. Used to hint what
3044
2620
    # code path for commit, amongst other things.
3045
2621
    fast_deltas = None
3046
 
    # Does doing a pack operation compress data? Useful for the pack UI command
3047
 
    # (so if there is one pack, the operation can still proceed because it may
3048
 
    # help), and for fetching when data won't have come from the same
3049
 
    # compressor.
3050
 
    pack_compresses = False
3051
 
    # Does the repository inventory storage understand references to trees?
3052
 
    supports_tree_reference = None
3053
 
    # Is the format experimental ?
3054
 
    experimental = False
3055
2622
 
3056
 
    def __repr__(self):
3057
 
        return "%s()" % self.__class__.__name__
 
2623
    def __str__(self):
 
2624
        return "<%s>" % self.__class__.__name__
3058
2625
 
3059
2626
    def __eq__(self, other):
3060
2627
        # format objects are generally stateless
3073
2640
        """
3074
2641
        try:
3075
2642
            transport = a_bzrdir.get_repository_transport(None)
3076
 
            format_string = transport.get_bytes("format")
 
2643
            format_string = transport.get("format").read()
3077
2644
            return format_registry.get(format_string)
3078
2645
        except errors.NoSuchFile:
3079
2646
            raise errors.NoRepositoryPresent(a_bzrdir)
3161
2728
        raise NotImplementedError(self.network_name)
3162
2729
 
3163
2730
    def check_conversion_target(self, target_format):
3164
 
        if self.rich_root_data and not target_format.rich_root_data:
3165
 
            raise errors.BadConversionTarget(
3166
 
                'Does not support rich root data.', target_format,
3167
 
                from_format=self)
3168
 
        if (self.supports_tree_reference and 
3169
 
            not getattr(target_format, 'supports_tree_reference', False)):
3170
 
            raise errors.BadConversionTarget(
3171
 
                'Does not support nested trees', target_format,
3172
 
                from_format=self)
 
2731
        raise NotImplementedError(self.check_conversion_target)
3173
2732
 
3174
2733
    def open(self, a_bzrdir, _found=False):
3175
2734
        """Return an instance of this format for the bzrdir a_bzrdir.
3178
2737
        """
3179
2738
        raise NotImplementedError(self.open)
3180
2739
 
3181
 
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
3182
 
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
3183
 
        hooks = BzrDir.hooks['post_repo_init']
3184
 
        if not hooks:
3185
 
            return
3186
 
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
3187
 
        for hook in hooks:
3188
 
            hook(params)
3189
 
 
3190
2740
 
3191
2741
class MetaDirRepositoryFormat(RepositoryFormat):
3192
2742
    """Common base class for the new repositories using the metadir layout."""
3240
2790
# Pre-0.8 formats that don't have a disk format string (because they are
3241
2791
# versioned by the matching control directory). We use the control directories
3242
2792
# disk format string as a key for the network_name because they meet the
3243
 
# constraints (simple string, unique, immutable).
 
2793
# constraints (simple string, unique, immmutable).
3244
2794
network_format_registry.register_lazy(
3245
2795
    "Bazaar-NG branch, format 5\n",
3246
2796
    'bzrlib.repofmt.weaverepo',
3327
2877
    )
3328
2878
 
3329
2879
# Development formats.
3330
 
# Obsolete but kept pending a CHK based subtree format.
 
2880
# 1.7->1.8 go below here
 
2881
format_registry.register_lazy(
 
2882
    "Bazaar development format 2 (needs bzr.dev from before 1.8)\n",
 
2883
    'bzrlib.repofmt.pack_repo',
 
2884
    'RepositoryFormatPackDevelopment2',
 
2885
    )
3331
2886
format_registry.register_lazy(
3332
2887
    ("Bazaar development format 2 with subtree support "
3333
2888
        "(needs bzr.dev from before 1.8)\n"),
3335
2890
    'RepositoryFormatPackDevelopment2Subtree',
3336
2891
    )
3337
2892
 
3338
 
# 1.14->1.16 go below here
3339
 
format_registry.register_lazy(
3340
 
    'Bazaar development format - group compression and chk inventory'
3341
 
        ' (needs bzr.dev from 1.14)\n',
3342
 
    'bzrlib.repofmt.groupcompress_repo',
3343
 
    'RepositoryFormatCHK1',
3344
 
    )
3345
 
 
3346
 
format_registry.register_lazy(
3347
 
    'Bazaar development format - chk repository with bencode revision '
3348
 
        'serialization (needs bzr.dev from 1.16)\n',
3349
 
    'bzrlib.repofmt.groupcompress_repo',
3350
 
    'RepositoryFormatCHK2',
3351
 
    )
3352
 
format_registry.register_lazy(
3353
 
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
3354
 
    'bzrlib.repofmt.groupcompress_repo',
3355
 
    'RepositoryFormat2a',
3356
 
    )
3357
 
 
3358
2893
 
3359
2894
class InterRepository(InterObject):
3360
2895
    """This class represents operations taking place between two repositories.
3397
2932
 
3398
2933
        :param revision_id: if None all content is copied, if NULL_REVISION no
3399
2934
                            content is copied.
3400
 
        :param pb: ignored.
 
2935
        :param pb: optional progress bar to use for progress reports. If not
 
2936
                   provided a default one will be created.
3401
2937
        :return: None.
3402
2938
        """
3403
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3404
2939
        from bzrlib.fetch import RepoFetcher
3405
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
3406
 
        if self.source._format.network_name() != self.target._format.network_name():
3407
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
3408
 
                from_format=self.source._format,
3409
 
                to_format=self.target._format)
3410
2940
        f = RepoFetcher(to_repository=self.target,
3411
2941
                               from_repository=self.source,
3412
2942
                               last_revision=revision_id,
3413
2943
                               fetch_spec=fetch_spec,
3414
 
                               find_ghosts=find_ghosts)
 
2944
                               pb=pb, find_ghosts=find_ghosts)
3415
2945
 
3416
2946
    def _walk_to_common_revisions(self, revision_ids):
3417
2947
        """Walk out from revision_ids in source to revisions target has.
3421
2951
        """
3422
2952
        target_graph = self.target.get_graph()
3423
2953
        revision_ids = frozenset(revision_ids)
 
2954
        # Fast path for the case where all the revisions are already in the
 
2955
        # target repo.
 
2956
        # (Although this does incur an extra round trip for the
 
2957
        # fairly common case where the target doesn't already have the revision
 
2958
        # we're pushing.)
 
2959
        if set(target_graph.get_parent_map(revision_ids)) == revision_ids:
 
2960
            return graph.SearchResult(revision_ids, set(), 0, set())
3424
2961
        missing_revs = set()
3425
2962
        source_graph = self.source.get_graph()
3426
2963
        # ensure we don't pay silly lookup costs.
3586
3123
                self.target.texts.insert_record_stream(
3587
3124
                    self.source.texts.get_record_stream(
3588
3125
                        self.source.texts.keys(), 'topological', False))
3589
 
                pb.update('Copying inventory', 0, 1)
 
3126
                pb.update('copying inventory', 0, 1)
3590
3127
                self.target.inventories.insert_record_stream(
3591
3128
                    self.source.inventories.get_record_stream(
3592
3129
                        self.source.inventories.keys(), 'topological', False))
3613
3150
        # so the first thing is to get a subset of the revisions to
3614
3151
        # satisfy revision_id in source, and then eliminate those that
3615
3152
        # we do already have.
3616
 
        # this is slow on high latency connection to self, but as this
 
3153
        # this is slow on high latency connection to self, but as as this
3617
3154
        # disk format scales terribly for push anyway due to rewriting
3618
3155
        # inventory.weave, this is considered acceptable.
3619
3156
        # - RBC 20060209
3706
3243
        return self.source.revision_ids_to_search_result(result_set)
3707
3244
 
3708
3245
 
3709
 
class InterDifferingSerializer(InterRepository):
 
3246
class InterPackRepo(InterSameDataRepository):
 
3247
    """Optimised code paths between Pack based repositories."""
 
3248
 
 
3249
    @classmethod
 
3250
    def _get_repo_format_to_test(self):
 
3251
        from bzrlib.repofmt import pack_repo
 
3252
        return pack_repo.RepositoryFormatKnitPack1()
 
3253
 
 
3254
    @staticmethod
 
3255
    def is_compatible(source, target):
 
3256
        """Be compatible with known Pack formats.
 
3257
 
 
3258
        We don't test for the stores being of specific types because that
 
3259
        could lead to confusing results, and there is no need to be
 
3260
        overly general.
 
3261
        """
 
3262
        from bzrlib.repofmt.pack_repo import RepositoryFormatPack
 
3263
        try:
 
3264
            are_packs = (isinstance(source._format, RepositoryFormatPack) and
 
3265
                isinstance(target._format, RepositoryFormatPack))
 
3266
        except AttributeError:
 
3267
            return False
 
3268
        return are_packs and InterRepository._same_model(source, target)
 
3269
 
 
3270
    @needs_write_lock
 
3271
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
3272
            fetch_spec=None):
 
3273
        """See InterRepository.fetch()."""
 
3274
        if (len(self.source._fallback_repositories) > 0 or
 
3275
            len(self.target._fallback_repositories) > 0):
 
3276
            # The pack layer is not aware of fallback repositories, so when
 
3277
            # fetching from a stacked repository or into a stacked repository
 
3278
            # we use the generic fetch logic which uses the VersionedFiles
 
3279
            # attributes on repository.
 
3280
            from bzrlib.fetch import RepoFetcher
 
3281
            fetcher = RepoFetcher(self.target, self.source, revision_id,
 
3282
                    pb, find_ghosts, fetch_spec=fetch_spec)
 
3283
        if fetch_spec is not None:
 
3284
            if len(list(fetch_spec.heads)) != 1:
 
3285
                raise AssertionError(
 
3286
                    "InterPackRepo.fetch doesn't support "
 
3287
                    "fetching multiple heads yet.")
 
3288
            revision_id = list(fetch_spec.heads)[0]
 
3289
            fetch_spec = None
 
3290
        if revision_id is None:
 
3291
            # TODO:
 
3292
            # everything to do - use pack logic
 
3293
            # to fetch from all packs to one without
 
3294
            # inventory parsing etc, IFF nothing to be copied is in the target.
 
3295
            # till then:
 
3296
            source_revision_ids = frozenset(self.source.all_revision_ids())
 
3297
            revision_ids = source_revision_ids - \
 
3298
                frozenset(self.target.get_parent_map(source_revision_ids))
 
3299
            revision_keys = [(revid,) for revid in revision_ids]
 
3300
            index = self.target._pack_collection.revision_index.combined_index
 
3301
            present_revision_ids = set(item[1][0] for item in
 
3302
                index.iter_entries(revision_keys))
 
3303
            revision_ids = set(revision_ids) - present_revision_ids
 
3304
            # implementing the TODO will involve:
 
3305
            # - detecting when all of a pack is selected
 
3306
            # - avoiding as much as possible pre-selection, so the
 
3307
            # more-core routines such as create_pack_from_packs can filter in
 
3308
            # a just-in-time fashion. (though having a HEADS list on a
 
3309
            # repository might make this a lot easier, because we could
 
3310
            # sensibly detect 'new revisions' without doing a full index scan.
 
3311
        elif _mod_revision.is_null(revision_id):
 
3312
            # nothing to do:
 
3313
            return (0, [])
 
3314
        else:
 
3315
            try:
 
3316
                revision_ids = self.search_missing_revision_ids(revision_id,
 
3317
                    find_ghosts=find_ghosts).get_keys()
 
3318
            except errors.NoSuchRevision:
 
3319
                raise errors.InstallFailed([revision_id])
 
3320
            if len(revision_ids) == 0:
 
3321
                return (0, [])
 
3322
        return self._pack(self.source, self.target, revision_ids)
 
3323
 
 
3324
    def _pack(self, source, target, revision_ids):
 
3325
        from bzrlib.repofmt.pack_repo import Packer
 
3326
        packs = source._pack_collection.all_packs()
 
3327
        pack = Packer(self.target._pack_collection, packs, '.fetch',
 
3328
            revision_ids).pack()
 
3329
        if pack is not None:
 
3330
            self.target._pack_collection._save_pack_names()
 
3331
            copied_revs = pack.get_revision_count()
 
3332
            # Trigger an autopack. This may duplicate effort as we've just done
 
3333
            # a pack creation, but for now it is simpler to think about as
 
3334
            # 'upload data, then repack if needed'.
 
3335
            self.target._pack_collection.autopack()
 
3336
            return (copied_revs, [])
 
3337
        else:
 
3338
            return (0, [])
 
3339
 
 
3340
    @needs_read_lock
 
3341
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
3342
        """See InterRepository.missing_revision_ids().
 
3343
 
 
3344
        :param find_ghosts: Find ghosts throughout the ancestry of
 
3345
            revision_id.
 
3346
        """
 
3347
        if not find_ghosts and revision_id is not None:
 
3348
            return self._walk_to_common_revisions([revision_id])
 
3349
        elif revision_id is not None:
 
3350
            # Find ghosts: search for revisions pointing from one repository to
 
3351
            # the other, and vice versa, anywhere in the history of revision_id.
 
3352
            graph = self.target.get_graph(other_repository=self.source)
 
3353
            searcher = graph._make_breadth_first_searcher([revision_id])
 
3354
            found_ids = set()
 
3355
            while True:
 
3356
                try:
 
3357
                    next_revs, ghosts = searcher.next_with_ghosts()
 
3358
                except StopIteration:
 
3359
                    break
 
3360
                if revision_id in ghosts:
 
3361
                    raise errors.NoSuchRevision(self.source, revision_id)
 
3362
                found_ids.update(next_revs)
 
3363
                found_ids.update(ghosts)
 
3364
            found_ids = frozenset(found_ids)
 
3365
            # Double query here: should be able to avoid this by changing the
 
3366
            # graph api further.
 
3367
            result_set = found_ids - frozenset(
 
3368
                self.target.get_parent_map(found_ids))
 
3369
        else:
 
3370
            source_ids = self.source.all_revision_ids()
 
3371
            # source_ids is the worst possible case we may need to pull.
 
3372
            # now we want to filter source_ids against what we actually
 
3373
            # have in target, but don't try to check for existence where we know
 
3374
            # we do not have a revision as that would be pointless.
 
3375
            target_ids = set(self.target.all_revision_ids())
 
3376
            result_set = set(source_ids).difference(target_ids)
 
3377
        return self.source.revision_ids_to_search_result(result_set)
 
3378
 
 
3379
 
 
3380
class InterDifferingSerializer(InterKnitRepo):
3710
3381
 
3711
3382
    @classmethod
3712
3383
    def _get_repo_format_to_test(self):
3715
3386
    @staticmethod
3716
3387
    def is_compatible(source, target):
3717
3388
        """Be compatible with Knit2 source and Knit3 target"""
3718
 
        # This is redundant with format.check_conversion_target(), however that
3719
 
        # raises an exception, and we just want to say "False" as in we won't
3720
 
        # support converting between these formats.
3721
 
        if 'IDS_never' in debug.debug_flags:
3722
 
            return False
3723
 
        if source.supports_rich_root() and not target.supports_rich_root():
3724
 
            return False
3725
 
        if (source._format.supports_tree_reference
3726
 
            and not target._format.supports_tree_reference):
3727
 
            return False
3728
 
        if target._fallback_repositories and target._format.supports_chks:
3729
 
            # IDS doesn't know how to copy CHKs for the parent inventories it
3730
 
            # adds to stacked repos.
3731
 
            return False
3732
 
        if 'IDS_always' in debug.debug_flags:
3733
 
            return True
3734
 
        # Only use this code path for local source and target.  IDS does far
3735
 
        # too much IO (both bandwidth and roundtrips) over a network.
3736
 
        if not source.bzrdir.transport.base.startswith('file:///'):
3737
 
            return False
3738
 
        if not target.bzrdir.transport.base.startswith('file:///'):
 
3389
        if source.supports_rich_root() != target.supports_rich_root():
 
3390
            return False
 
3391
        # Ideally, we'd support fetching if the source had no tree references
 
3392
        # even if it supported them...
 
3393
        if (getattr(source, '_format.supports_tree_reference', False) and
 
3394
            not getattr(target, '_format.supports_tree_reference', False)):
3739
3395
            return False
3740
3396
        return True
3741
3397
 
3742
 
    def _get_trees(self, revision_ids, cache):
3743
 
        possible_trees = []
3744
 
        for rev_id in revision_ids:
3745
 
            if rev_id in cache:
3746
 
                possible_trees.append((rev_id, cache[rev_id]))
3747
 
            else:
3748
 
                # Not cached, but inventory might be present anyway.
3749
 
                try:
3750
 
                    tree = self.source.revision_tree(rev_id)
3751
 
                except errors.NoSuchRevision:
3752
 
                    # Nope, parent is ghost.
3753
 
                    pass
3754
 
                else:
3755
 
                    cache[rev_id] = tree
3756
 
                    possible_trees.append((rev_id, tree))
3757
 
        return possible_trees
3758
 
 
3759
 
    def _get_delta_for_revision(self, tree, parent_ids, possible_trees):
 
3398
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3760
3399
        """Get the best delta and base for this revision.
3761
3400
 
3762
3401
        :return: (basis_id, delta)
3763
3402
        """
 
3403
        possible_trees = [(parent_id, cache[parent_id])
 
3404
                          for parent_id in parent_ids
 
3405
                           if parent_id in cache]
 
3406
        if len(possible_trees) == 0:
 
3407
            # There either aren't any parents, or the parents aren't in the
 
3408
            # cache, so just use the last converted tree
 
3409
            possible_trees.append((basis_id, cache[basis_id]))
3764
3410
        deltas = []
3765
 
        # Generate deltas against each tree, to find the shortest.
3766
 
        texts_possibly_new_in_tree = set()
3767
3411
        for basis_id, basis_tree in possible_trees:
3768
3412
            delta = tree.inventory._make_delta(basis_tree.inventory)
3769
 
            for old_path, new_path, file_id, new_entry in delta:
3770
 
                if new_path is None:
3771
 
                    # This file_id isn't present in the new rev, so we don't
3772
 
                    # care about it.
3773
 
                    continue
3774
 
                if not new_path:
3775
 
                    # Rich roots are handled elsewhere...
3776
 
                    continue
3777
 
                kind = new_entry.kind
3778
 
                if kind != 'directory' and kind != 'file':
3779
 
                    # No text record associated with this inventory entry.
3780
 
                    continue
3781
 
                # This is a directory or file that has changed somehow.
3782
 
                texts_possibly_new_in_tree.add((file_id, new_entry.revision))
3783
3413
            deltas.append((len(delta), basis_id, delta))
3784
3414
        deltas.sort()
3785
3415
        return deltas[0][1:]
3786
3416
 
3787
 
    def _fetch_parent_invs_for_stacking(self, parent_map, cache):
3788
 
        """Find all parent revisions that are absent, but for which the
3789
 
        inventory is present, and copy those inventories.
3790
 
 
3791
 
        This is necessary to preserve correctness when the source is stacked
3792
 
        without fallbacks configured.  (Note that in cases like upgrade the
3793
 
        source may be not have _fallback_repositories even though it is
3794
 
        stacked.)
3795
 
        """
3796
 
        parent_revs = set()
3797
 
        for parents in parent_map.values():
3798
 
            parent_revs.update(parents)
3799
 
        present_parents = self.source.get_parent_map(parent_revs)
3800
 
        absent_parents = set(parent_revs).difference(present_parents)
3801
 
        parent_invs_keys_for_stacking = self.source.inventories.get_parent_map(
3802
 
            (rev_id,) for rev_id in absent_parents)
3803
 
        parent_inv_ids = [key[-1] for key in parent_invs_keys_for_stacking]
3804
 
        for parent_tree in self.source.revision_trees(parent_inv_ids):
3805
 
            current_revision_id = parent_tree.get_revision_id()
3806
 
            parents_parents_keys = parent_invs_keys_for_stacking[
3807
 
                (current_revision_id,)]
3808
 
            parents_parents = [key[-1] for key in parents_parents_keys]
3809
 
            basis_id = _mod_revision.NULL_REVISION
3810
 
            basis_tree = self.source.revision_tree(basis_id)
3811
 
            delta = parent_tree.inventory._make_delta(basis_tree.inventory)
3812
 
            self.target.add_inventory_by_delta(
3813
 
                basis_id, delta, current_revision_id, parents_parents)
3814
 
            cache[current_revision_id] = parent_tree
3815
 
 
3816
 
    def _fetch_batch(self, revision_ids, basis_id, cache, a_graph=None):
 
3417
    def _fetch_batch(self, revision_ids, basis_id, cache):
3817
3418
        """Fetch across a few revisions.
3818
3419
 
3819
3420
        :param revision_ids: The revisions to copy
3820
3421
        :param basis_id: The revision_id of a tree that must be in cache, used
3821
3422
            as a basis for delta when no other base is available
3822
3423
        :param cache: A cache of RevisionTrees that we can use.
3823
 
        :param a_graph: A Graph object to determine the heads() of the
3824
 
            rich-root data stream.
3825
3424
        :return: The revision_id of the last converted tree. The RevisionTree
3826
3425
            for it will be in cache
3827
3426
        """
3828
3427
        # Walk though all revisions; get inventory deltas, copy referenced
3829
3428
        # texts that delta references, insert the delta, revision and
3830
3429
        # signature.
3831
 
        root_keys_to_create = set()
3832
3430
        text_keys = set()
3833
3431
        pending_deltas = []
3834
3432
        pending_revisions = []
3835
3433
        parent_map = self.source.get_parent_map(revision_ids)
3836
 
        self._fetch_parent_invs_for_stacking(parent_map, cache)
3837
 
        self.source._safe_to_return_from_cache = True
3838
3434
        for tree in self.source.revision_trees(revision_ids):
3839
 
            # Find a inventory delta for this revision.
3840
 
            # Find text entries that need to be copied, too.
3841
3435
            current_revision_id = tree.get_revision_id()
3842
3436
            parent_ids = parent_map.get(current_revision_id, ())
3843
 
            parent_trees = self._get_trees(parent_ids, cache)
3844
 
            possible_trees = list(parent_trees)
3845
 
            if len(possible_trees) == 0:
3846
 
                # There either aren't any parents, or the parents are ghosts,
3847
 
                # so just use the last converted tree.
3848
 
                possible_trees.append((basis_id, cache[basis_id]))
3849
3437
            basis_id, delta = self._get_delta_for_revision(tree, parent_ids,
3850
 
                                                           possible_trees)
 
3438
                                                           basis_id, cache)
 
3439
            # Find text entries that need to be copied
 
3440
            for old_path, new_path, file_id, entry in delta:
 
3441
                if new_path is not None:
 
3442
                    if not (new_path or self.target.supports_rich_root()):
 
3443
                        # We don't copy the text for the root node unless the
 
3444
                        # target supports_rich_root.
 
3445
                        continue
 
3446
                    text_keys.add((file_id, entry.revision))
3851
3447
            revision = self.source.get_revision(current_revision_id)
3852
3448
            pending_deltas.append((basis_id, delta,
3853
3449
                current_revision_id, revision.parent_ids))
3854
 
            if self._converting_to_rich_root:
3855
 
                self._revision_id_to_root_id[current_revision_id] = \
3856
 
                    tree.get_root_id()
3857
 
            # Determine which texts are in present in this revision but not in
3858
 
            # any of the available parents.
3859
 
            texts_possibly_new_in_tree = set()
3860
 
            for old_path, new_path, file_id, entry in delta:
3861
 
                if new_path is None:
3862
 
                    # This file_id isn't present in the new rev
3863
 
                    continue
3864
 
                if not new_path:
3865
 
                    # This is the root
3866
 
                    if not self.target.supports_rich_root():
3867
 
                        # The target doesn't support rich root, so we don't
3868
 
                        # copy
3869
 
                        continue
3870
 
                    if self._converting_to_rich_root:
3871
 
                        # This can't be copied normally, we have to insert
3872
 
                        # it specially
3873
 
                        root_keys_to_create.add((file_id, entry.revision))
3874
 
                        continue
3875
 
                kind = entry.kind
3876
 
                texts_possibly_new_in_tree.add((file_id, entry.revision))
3877
 
            for basis_id, basis_tree in possible_trees:
3878
 
                basis_inv = basis_tree.inventory
3879
 
                for file_key in list(texts_possibly_new_in_tree):
3880
 
                    file_id, file_revision = file_key
3881
 
                    try:
3882
 
                        entry = basis_inv[file_id]
3883
 
                    except errors.NoSuchId:
3884
 
                        continue
3885
 
                    if entry.revision == file_revision:
3886
 
                        texts_possibly_new_in_tree.remove(file_key)
3887
 
            text_keys.update(texts_possibly_new_in_tree)
3888
3450
            pending_revisions.append(revision)
3889
3451
            cache[current_revision_id] = tree
3890
3452
            basis_id = current_revision_id
3891
 
        self.source._safe_to_return_from_cache = False
3892
3453
        # Copy file texts
3893
3454
        from_texts = self.source.texts
3894
3455
        to_texts = self.target.texts
3895
 
        if root_keys_to_create:
3896
 
            root_stream = _mod_fetch._new_root_data_stream(
3897
 
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
3898
 
                self.source, graph=a_graph)
3899
 
            to_texts.insert_record_stream(root_stream)
3900
3456
        to_texts.insert_record_stream(from_texts.get_record_stream(
3901
3457
            text_keys, self.target._format._fetch_order,
3902
3458
            not self.target._format._fetch_uses_deltas))
3903
 
        # insert inventory deltas
 
3459
        # insert deltas
3904
3460
        for delta in pending_deltas:
3905
3461
            self.target.add_inventory_by_delta(*delta)
3906
 
        if self.target._fallback_repositories:
3907
 
            # Make sure this stacked repository has all the parent inventories
3908
 
            # for the new revisions that we are about to insert.  We do this
3909
 
            # before adding the revisions so that no revision is added until
3910
 
            # all the inventories it may depend on are added.
3911
 
            # Note that this is overzealous, as we may have fetched these in an
3912
 
            # earlier batch.
3913
 
            parent_ids = set()
3914
 
            revision_ids = set()
3915
 
            for revision in pending_revisions:
3916
 
                revision_ids.add(revision.revision_id)
3917
 
                parent_ids.update(revision.parent_ids)
3918
 
            parent_ids.difference_update(revision_ids)
3919
 
            parent_ids.discard(_mod_revision.NULL_REVISION)
3920
 
            parent_map = self.source.get_parent_map(parent_ids)
3921
 
            # we iterate over parent_map and not parent_ids because we don't
3922
 
            # want to try copying any revision which is a ghost
3923
 
            for parent_tree in self.source.revision_trees(parent_map):
3924
 
                current_revision_id = parent_tree.get_revision_id()
3925
 
                parents_parents = parent_map[current_revision_id]
3926
 
                possible_trees = self._get_trees(parents_parents, cache)
3927
 
                if len(possible_trees) == 0:
3928
 
                    # There either aren't any parents, or the parents are
3929
 
                    # ghosts, so just use the last converted tree.
3930
 
                    possible_trees.append((basis_id, cache[basis_id]))
3931
 
                basis_id, delta = self._get_delta_for_revision(parent_tree,
3932
 
                    parents_parents, possible_trees)
3933
 
                self.target.add_inventory_by_delta(
3934
 
                    basis_id, delta, current_revision_id, parents_parents)
3935
3462
        # insert signatures and revisions
3936
3463
        for revision in pending_revisions:
3937
3464
            try:
3949
3476
 
3950
3477
        :param revision_ids: The list of revisions to fetch. Must be in
3951
3478
            topological order.
3952
 
        :param pb: A ProgressTask
 
3479
        :param pb: A ProgressBar
3953
3480
        :return: None
3954
3481
        """
3955
3482
        basis_id, basis_tree = self._get_basis(revision_ids[0])
3957
3484
        cache = lru_cache.LRUCache(100)
3958
3485
        cache[basis_id] = basis_tree
3959
3486
        del basis_tree # We don't want to hang on to it here
3960
 
        hints = []
3961
 
        if self._converting_to_rich_root and len(revision_ids) > 100:
3962
 
            a_graph = _mod_fetch._get_rich_root_heads_graph(self.source,
3963
 
                                                            revision_ids)
3964
 
        else:
3965
 
            a_graph = None
3966
 
 
3967
3487
        for offset in range(0, len(revision_ids), batch_size):
3968
3488
            self.target.start_write_group()
3969
3489
            try:
3970
3490
                pb.update('Transferring revisions', offset,
3971
3491
                          len(revision_ids))
3972
3492
                batch = revision_ids[offset:offset+batch_size]
3973
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
3974
 
                                             a_graph=a_graph)
 
3493
                basis_id = self._fetch_batch(batch, basis_id, cache)
3975
3494
            except:
3976
 
                self.source._safe_to_return_from_cache = False
3977
3495
                self.target.abort_write_group()
3978
3496
                raise
3979
3497
            else:
3980
 
                hint = self.target.commit_write_group()
3981
 
                if hint:
3982
 
                    hints.extend(hint)
3983
 
        if hints and self.target._format.pack_compresses:
3984
 
            self.target.pack(hint=hints)
 
3498
                self.target.commit_write_group()
3985
3499
        pb.update('Transferring revisions', len(revision_ids),
3986
3500
                  len(revision_ids))
3987
3501
 
3991
3505
        """See InterRepository.fetch()."""
3992
3506
        if fetch_spec is not None:
3993
3507
            raise AssertionError("Not implemented yet...")
3994
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3995
 
        if (not self.source.supports_rich_root()
3996
 
            and self.target.supports_rich_root()):
3997
 
            self._converting_to_rich_root = True
3998
 
            self._revision_id_to_root_id = {}
3999
 
        else:
4000
 
            self._converting_to_rich_root = False
4001
 
        # See <https://launchpad.net/bugs/456077> asking for a warning here
4002
 
        if self.source._format.network_name() != self.target._format.network_name():
4003
 
            ui.ui_factory.show_user_warning('cross_format_fetch',
4004
 
                from_format=self.source._format,
4005
 
                to_format=self.target._format)
4006
3508
        revision_ids = self.target.search_missing_revision_ids(self.source,
4007
3509
            revision_id, find_ghosts=find_ghosts).get_keys()
4008
3510
        if not revision_ids:
4009
3511
            return 0, 0
4010
3512
        revision_ids = tsort.topo_sort(
4011
3513
            self.source.get_graph().get_parent_map(revision_ids))
4012
 
        if not revision_ids:
4013
 
            return 0, 0
4014
 
        # Walk though all revisions; get inventory deltas, copy referenced
4015
 
        # texts that delta references, insert the delta, revision and
4016
 
        # signature.
4017
3514
        if pb is None:
4018
3515
            my_pb = ui.ui_factory.nested_progress_bar()
4019
3516
            pb = my_pb
4056
3553
InterRepository.register_optimiser(InterSameDataRepository)
4057
3554
InterRepository.register_optimiser(InterWeaveRepo)
4058
3555
InterRepository.register_optimiser(InterKnitRepo)
 
3556
InterRepository.register_optimiser(InterPackRepo)
4059
3557
 
4060
3558
 
4061
3559
class CopyConverter(object):
4077
3575
        :param to_convert: The disk object to convert.
4078
3576
        :param pb: a progress bar to use for progress information.
4079
3577
        """
4080
 
        pb = ui.ui_factory.nested_progress_bar()
 
3578
        self.pb = pb
4081
3579
        self.count = 0
4082
3580
        self.total = 4
4083
3581
        # this is only useful with metadir layouts - separated repo content.
4084
3582
        # trigger an assertion if not such
4085
3583
        repo._format.get_format_string()
4086
3584
        self.repo_dir = repo.bzrdir
4087
 
        pb.update('Moving repository to repository.backup')
 
3585
        self.step('Moving repository to repository.backup')
4088
3586
        self.repo_dir.transport.move('repository', 'repository.backup')
4089
3587
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
4090
3588
        repo._format.check_conversion_target(self.target_format)
4091
3589
        self.source_repo = repo._format.open(self.repo_dir,
4092
3590
            _found=True,
4093
3591
            _override_transport=backup_transport)
4094
 
        pb.update('Creating new repository')
 
3592
        self.step('Creating new repository')
4095
3593
        converted = self.target_format.initialize(self.repo_dir,
4096
3594
                                                  self.source_repo.is_shared())
4097
3595
        converted.lock_write()
4098
3596
        try:
4099
 
            pb.update('Copying content')
 
3597
            self.step('Copying content into repository.')
4100
3598
            self.source_repo.copy_content_into(converted)
4101
3599
        finally:
4102
3600
            converted.unlock()
4103
 
        pb.update('Deleting old repository content')
 
3601
        self.step('Deleting old repository content.')
4104
3602
        self.repo_dir.transport.delete_tree('repository.backup')
4105
 
        ui.ui_factory.note('repository converted')
4106
 
        pb.finished()
 
3603
        self.pb.note('repository converted')
 
3604
 
 
3605
    def step(self, message):
 
3606
        """Update the pb by a step."""
 
3607
        self.count +=1
 
3608
        self.pb.update(message, self.count, self.total)
4107
3609
 
4108
3610
 
4109
3611
_unescape_map = {
4138
3640
 
4139
3641
class _VersionedFileChecker(object):
4140
3642
 
4141
 
    def __init__(self, repository, text_key_references=None, ancestors=None):
 
3643
    def __init__(self, repository, text_key_references=None):
4142
3644
        self.repository = repository
4143
3645
        self.text_index = self.repository._generate_text_key_index(
4144
 
            text_key_references=text_key_references, ancestors=ancestors)
 
3646
            text_key_references=text_key_references)
4145
3647
 
4146
3648
    def calculate_file_version_parents(self, text_key):
4147
3649
        """Calculate the correct parents for a file version according to
4165
3667
            revision_id) tuples for versions that are present in this versioned
4166
3668
            file, but not used by the corresponding inventory.
4167
3669
        """
4168
 
        local_progress = None
4169
 
        if progress_bar is None:
4170
 
            local_progress = ui.ui_factory.nested_progress_bar()
4171
 
            progress_bar = local_progress
4172
 
        try:
4173
 
            return self._check_file_version_parents(texts, progress_bar)
4174
 
        finally:
4175
 
            if local_progress:
4176
 
                local_progress.finished()
4177
 
 
4178
 
    def _check_file_version_parents(self, texts, progress_bar):
4179
 
        """See check_file_version_parents."""
4180
3670
        wrong_parents = {}
4181
3671
        self.file_ids = set([file_id for file_id, _ in
4182
3672
            self.text_index.iterkeys()])
4183
3673
        # text keys is now grouped by file_id
 
3674
        n_weaves = len(self.file_ids)
 
3675
        files_in_revisions = {}
 
3676
        revisions_of_files = {}
4184
3677
        n_versions = len(self.text_index)
4185
3678
        progress_bar.update('loading text store', 0, n_versions)
4186
3679
        parent_map = self.repository.texts.get_parent_map(self.text_index)
4188
3681
        text_keys = self.repository.texts.keys()
4189
3682
        unused_keys = frozenset(text_keys) - set(self.text_index)
4190
3683
        for num, key in enumerate(self.text_index.iterkeys()):
4191
 
            progress_bar.update('checking text graph', num, n_versions)
 
3684
            if progress_bar is not None:
 
3685
                progress_bar.update('checking text graph', num, n_versions)
4192
3686
            correct_parents = self.calculate_file_version_parents(key)
4193
3687
            try:
4194
3688
                knit_parents = parent_map[key]
4243
3737
        try:
4244
3738
            if resume_tokens:
4245
3739
                self.target_repo.resume_write_group(resume_tokens)
4246
 
                is_resume = True
4247
3740
            else:
4248
3741
                self.target_repo.start_write_group()
4249
 
                is_resume = False
4250
3742
            try:
4251
3743
                # locked_insert_stream performs a commit|suspend.
4252
 
                return self._locked_insert_stream(stream, src_format, is_resume)
 
3744
                return self._locked_insert_stream(stream, src_format)
4253
3745
            except:
4254
3746
                self.target_repo.abort_write_group(suppress_errors=True)
4255
3747
                raise
4256
3748
        finally:
4257
3749
            self.target_repo.unlock()
4258
3750
 
4259
 
    def _locked_insert_stream(self, stream, src_format, is_resume):
 
3751
    def _locked_insert_stream(self, stream, src_format):
4260
3752
        to_serializer = self.target_repo._format._serializer
4261
3753
        src_serializer = src_format._serializer
4262
 
        new_pack = None
4263
3754
        if to_serializer == src_serializer:
4264
3755
            # If serializers match and the target is a pack repository, set the
4265
3756
            # write cache size on the new pack.  This avoids poor performance
4279
3770
            else:
4280
3771
                new_pack.set_write_cache_size(1024*1024)
4281
3772
        for substream_type, substream in stream:
4282
 
            if 'stream' in debug.debug_flags:
4283
 
                mutter('inserting substream: %s', substream_type)
4284
3773
            if substream_type == 'texts':
4285
3774
                self.target_repo.texts.insert_record_stream(substream)
4286
3775
            elif substream_type == 'inventories':
4290
3779
                else:
4291
3780
                    self._extract_and_insert_inventories(
4292
3781
                        substream, src_serializer)
4293
 
            elif substream_type == 'inventory-deltas':
4294
 
                self._extract_and_insert_inventory_deltas(
4295
 
                    substream, src_serializer)
4296
 
            elif substream_type == 'chk_bytes':
4297
 
                # XXX: This doesn't support conversions, as it assumes the
4298
 
                #      conversion was done in the fetch code.
4299
 
                self.target_repo.chk_bytes.insert_record_stream(substream)
4300
3782
            elif substream_type == 'revisions':
4301
3783
                # This may fallback to extract-and-insert more often than
4302
3784
                # required if the serializers are different only in terms of
4311
3793
                self.target_repo.signatures.insert_record_stream(substream)
4312
3794
            else:
4313
3795
                raise AssertionError('kaboom! %s' % (substream_type,))
4314
 
        # Done inserting data, and the missing_keys calculations will try to
4315
 
        # read back from the inserted data, so flush the writes to the new pack
4316
 
        # (if this is pack format).
4317
 
        if new_pack is not None:
4318
 
            new_pack._write_data('', flush=True)
4319
 
        # Find all the new revisions (including ones from resume_tokens)
4320
 
        missing_keys = self.target_repo.get_missing_parent_inventories(
4321
 
            check_for_missing_texts=is_resume)
4322
3796
        try:
 
3797
            missing_keys = set()
4323
3798
            for prefix, versioned_file in (
4324
3799
                ('texts', self.target_repo.texts),
4325
3800
                ('inventories', self.target_repo.inventories),
4326
3801
                ('revisions', self.target_repo.revisions),
4327
3802
                ('signatures', self.target_repo.signatures),
4328
 
                ('chk_bytes', self.target_repo.chk_bytes),
4329
3803
                ):
4330
 
                if versioned_file is None:
4331
 
                    continue
4332
 
                # TODO: key is often going to be a StaticTuple object
4333
 
                #       I don't believe we can define a method by which
4334
 
                #       (prefix,) + StaticTuple will work, though we could
4335
 
                #       define a StaticTuple.sq_concat that would allow you to
4336
 
                #       pass in either a tuple or a StaticTuple as the second
4337
 
                #       object, so instead we could have:
4338
 
                #       StaticTuple(prefix) + key here...
4339
3804
                missing_keys.update((prefix,) + key for key in
4340
3805
                    versioned_file.get_missing_compression_parent_keys())
4341
3806
        except NotImplementedError:
4350
3815
                # missing keys can handle suspending a write group).
4351
3816
                write_group_tokens = self.target_repo.suspend_write_group()
4352
3817
                return write_group_tokens, missing_keys
4353
 
        hint = self.target_repo.commit_write_group()
4354
 
        if (to_serializer != src_serializer and
4355
 
            self.target_repo._format.pack_compresses):
4356
 
            self.target_repo.pack(hint=hint)
 
3818
        self.target_repo.commit_write_group()
4357
3819
        return [], set()
4358
3820
 
4359
 
    def _extract_and_insert_inventory_deltas(self, substream, serializer):
4360
 
        target_rich_root = self.target_repo._format.rich_root_data
4361
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4362
 
        for record in substream:
4363
 
            # Insert the delta directly
4364
 
            inventory_delta_bytes = record.get_bytes_as('fulltext')
4365
 
            deserialiser = inventory_delta.InventoryDeltaDeserializer()
4366
 
            try:
4367
 
                parse_result = deserialiser.parse_text_bytes(
4368
 
                    inventory_delta_bytes)
4369
 
            except inventory_delta.IncompatibleInventoryDelta, err:
4370
 
                trace.mutter("Incompatible delta: %s", err.msg)
4371
 
                raise errors.IncompatibleRevision(self.target_repo._format)
4372
 
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
4373
 
            revision_id = new_id
4374
 
            parents = [key[0] for key in record.parents]
4375
 
            self.target_repo.add_inventory_by_delta(
4376
 
                basis_id, inv_delta, revision_id, parents)
4377
 
 
4378
 
    def _extract_and_insert_inventories(self, substream, serializer,
4379
 
            parse_delta=None):
 
3821
    def _extract_and_insert_inventories(self, substream, serializer):
4380
3822
        """Generate a new inventory versionedfile in target, converting data.
4381
3823
 
4382
3824
        The inventory is retrieved from the source, (deserializing it), and
4383
3825
        stored in the target (reserializing it in a different format).
4384
3826
        """
4385
 
        target_rich_root = self.target_repo._format.rich_root_data
4386
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4387
3827
        for record in substream:
4388
 
            # It's not a delta, so it must be a fulltext in the source
4389
 
            # serializer's format.
4390
3828
            bytes = record.get_bytes_as('fulltext')
4391
3829
            revision_id = record.key[0]
4392
3830
            inv = serializer.read_inventory_from_string(bytes, revision_id)
4393
3831
            parents = [key[0] for key in record.parents]
4394
3832
            self.target_repo.add_inventory(revision_id, inv, parents)
4395
 
            # No need to keep holding this full inv in memory when the rest of
4396
 
            # the substream is likely to be all deltas.
4397
 
            del inv
4398
3833
 
4399
3834
    def _extract_and_insert_revisions(self, substream, serializer):
4400
3835
        for record in substream:
4449
3884
        return [('signatures', signatures), ('revisions', revisions)]
4450
3885
 
4451
3886
    def _generate_root_texts(self, revs):
4452
 
        """This will be called by get_stream between fetching weave texts and
 
3887
        """This will be called by __fetch between fetching weave texts and
4453
3888
        fetching the inventory weave.
 
3889
 
 
3890
        Subclasses should override this if they need to generate root texts
 
3891
        after fetching weave texts.
4454
3892
        """
4455
3893
        if self._rich_root_upgrade():
4456
 
            return _mod_fetch.Inter1and2Helper(
 
3894
            import bzrlib.fetch
 
3895
            return bzrlib.fetch.Inter1and2Helper(
4457
3896
                self.from_repository).generate_root_texts(revs)
4458
3897
        else:
4459
3898
            return []
4462
3901
        phase = 'file'
4463
3902
        revs = search.get_keys()
4464
3903
        graph = self.from_repository.get_graph()
4465
 
        revs = tsort.topo_sort(graph.get_parent_map(revs))
 
3904
        revs = list(graph.iter_topo_order(revs))
4466
3905
        data_to_fetch = self.from_repository.item_keys_introduced_by(revs)
4467
3906
        text_keys = []
4468
3907
        for knit_kind, file_id, revisions in data_to_fetch:
4487
3926
                # will be valid.
4488
3927
                for _ in self._generate_root_texts(revs):
4489
3928
                    yield _
 
3929
                # NB: This currently reopens the inventory weave in source;
 
3930
                # using a single stream interface instead would avoid this.
 
3931
                from_weave = self.from_repository.inventories
4490
3932
                # we fetch only the referenced inventories because we do not
4491
3933
                # know for unselected inventories whether all their required
4492
3934
                # texts are present in the other repository - it could be
4493
3935
                # corrupt.
4494
 
                for info in self._get_inventory_stream(revs):
4495
 
                    yield info
 
3936
                yield ('inventories', from_weave.get_record_stream(
 
3937
                    [(rev_id,) for rev_id in revs],
 
3938
                    self.inventory_fetch_order(),
 
3939
                    not self.delta_on_metadata()))
4496
3940
            elif knit_kind == "signatures":
4497
3941
                # Nothing to do here; this will be taken care of when
4498
3942
                # _fetch_revision_texts happens.
4511
3955
        keys['texts'] = set()
4512
3956
        keys['revisions'] = set()
4513
3957
        keys['inventories'] = set()
4514
 
        keys['chk_bytes'] = set()
4515
3958
        keys['signatures'] = set()
4516
3959
        for key in missing_keys:
4517
3960
            keys[key[0]].add(key[1:])
4524
3967
                    keys['revisions'],))
4525
3968
        for substream_kind, keys in keys.iteritems():
4526
3969
            vf = getattr(self.from_repository, substream_kind)
4527
 
            if vf is None and keys:
4528
 
                    raise AssertionError(
4529
 
                        "cannot fill in keys for a versioned file we don't"
4530
 
                        " have: %s needs %s" % (substream_kind, keys))
4531
 
            if not keys:
4532
 
                # No need to stream something we don't have
4533
 
                continue
4534
 
            if substream_kind == 'inventories':
4535
 
                # Some missing keys are genuinely ghosts, filter those out.
4536
 
                present = self.from_repository.inventories.get_parent_map(keys)
4537
 
                revs = [key[0] for key in present]
4538
 
                # Get the inventory stream more-or-less as we do for the
4539
 
                # original stream; there's no reason to assume that records
4540
 
                # direct from the source will be suitable for the sink.  (Think
4541
 
                # e.g. 2a -> 1.9-rich-root).
4542
 
                for info in self._get_inventory_stream(revs, missing=True):
4543
 
                    yield info
4544
 
                continue
4545
 
 
4546
3970
            # Ask for full texts always so that we don't need more round trips
4547
3971
            # after this stream.
4548
 
            # Some of the missing keys are genuinely ghosts, so filter absent
4549
 
            # records. The Sink is responsible for doing another check to
4550
 
            # ensure that ghosts don't introduce missing data for future
4551
 
            # fetches.
4552
 
            stream = versionedfile.filter_absent(vf.get_record_stream(keys,
4553
 
                self.to_format._fetch_order, True))
 
3972
            stream = vf.get_record_stream(keys,
 
3973
                self.to_format._fetch_order, True)
4554
3974
            yield substream_kind, stream
4555
3975
 
4556
3976
    def inventory_fetch_order(self):
4563
3983
        return (not self.from_repository._format.rich_root_data and
4564
3984
            self.to_format.rich_root_data)
4565
3985
 
4566
 
    def _get_inventory_stream(self, revision_ids, missing=False):
4567
 
        from_format = self.from_repository._format
4568
 
        if (from_format.supports_chks and self.to_format.supports_chks and
4569
 
            from_format.network_name() == self.to_format.network_name()):
4570
 
            raise AssertionError(
4571
 
                "this case should be handled by GroupCHKStreamSource")
4572
 
        elif 'forceinvdeltas' in debug.debug_flags:
4573
 
            return self._get_convertable_inventory_stream(revision_ids,
4574
 
                    delta_versus_null=missing)
4575
 
        elif from_format.network_name() == self.to_format.network_name():
4576
 
            # Same format.
4577
 
            return self._get_simple_inventory_stream(revision_ids,
4578
 
                    missing=missing)
4579
 
        elif (not from_format.supports_chks and not self.to_format.supports_chks
4580
 
                and from_format._serializer == self.to_format._serializer):
4581
 
            # Essentially the same format.
4582
 
            return self._get_simple_inventory_stream(revision_ids,
4583
 
                    missing=missing)
4584
 
        else:
4585
 
            # Any time we switch serializations, we want to use an
4586
 
            # inventory-delta based approach.
4587
 
            return self._get_convertable_inventory_stream(revision_ids,
4588
 
                    delta_versus_null=missing)
4589
 
 
4590
 
    def _get_simple_inventory_stream(self, revision_ids, missing=False):
4591
 
        # NB: This currently reopens the inventory weave in source;
4592
 
        # using a single stream interface instead would avoid this.
4593
 
        from_weave = self.from_repository.inventories
4594
 
        if missing:
4595
 
            delta_closure = True
4596
 
        else:
4597
 
            delta_closure = not self.delta_on_metadata()
4598
 
        yield ('inventories', from_weave.get_record_stream(
4599
 
            [(rev_id,) for rev_id in revision_ids],
4600
 
            self.inventory_fetch_order(), delta_closure))
4601
 
 
4602
 
    def _get_convertable_inventory_stream(self, revision_ids,
4603
 
                                          delta_versus_null=False):
4604
 
        # The two formats are sufficiently different that there is no fast
4605
 
        # path, so we need to send just inventorydeltas, which any
4606
 
        # sufficiently modern client can insert into any repository.
4607
 
        # The StreamSink code expects to be able to
4608
 
        # convert on the target, so we need to put bytes-on-the-wire that can
4609
 
        # be converted.  That means inventory deltas (if the remote is <1.19,
4610
 
        # RemoteStreamSink will fallback to VFS to insert the deltas).
4611
 
        yield ('inventory-deltas',
4612
 
           self._stream_invs_as_deltas(revision_ids,
4613
 
                                       delta_versus_null=delta_versus_null))
4614
 
 
4615
 
    def _stream_invs_as_deltas(self, revision_ids, delta_versus_null=False):
4616
 
        """Return a stream of inventory-deltas for the given rev ids.
4617
 
 
4618
 
        :param revision_ids: The list of inventories to transmit
4619
 
        :param delta_versus_null: Don't try to find a minimal delta for this
4620
 
            entry, instead compute the delta versus the NULL_REVISION. This
4621
 
            effectively streams a complete inventory. Used for stuff like
4622
 
            filling in missing parents, etc.
4623
 
        """
4624
 
        from_repo = self.from_repository
4625
 
        revision_keys = [(rev_id,) for rev_id in revision_ids]
4626
 
        parent_map = from_repo.inventories.get_parent_map(revision_keys)
4627
 
        # XXX: possibly repos could implement a more efficient iter_inv_deltas
4628
 
        # method...
4629
 
        inventories = self.from_repository.iter_inventories(
4630
 
            revision_ids, 'topological')
4631
 
        format = from_repo._format
4632
 
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
4633
 
        inventory_cache = lru_cache.LRUCache(50)
4634
 
        null_inventory = from_repo.revision_tree(
4635
 
            _mod_revision.NULL_REVISION).inventory
4636
 
        # XXX: ideally the rich-root/tree-refs flags would be per-revision, not
4637
 
        # per-repo (e.g.  streaming a non-rich-root revision out of a rich-root
4638
 
        # repo back into a non-rich-root repo ought to be allowed)
4639
 
        serializer = inventory_delta.InventoryDeltaSerializer(
4640
 
            versioned_root=format.rich_root_data,
4641
 
            tree_references=format.supports_tree_reference)
4642
 
        for inv in inventories:
4643
 
            key = (inv.revision_id,)
4644
 
            parent_keys = parent_map.get(key, ())
4645
 
            delta = None
4646
 
            if not delta_versus_null and parent_keys:
4647
 
                # The caller did not ask for complete inventories and we have
4648
 
                # some parents that we can delta against.  Make a delta against
4649
 
                # each parent so that we can find the smallest.
4650
 
                parent_ids = [parent_key[0] for parent_key in parent_keys]
4651
 
                for parent_id in parent_ids:
4652
 
                    if parent_id not in invs_sent_so_far:
4653
 
                        # We don't know that the remote side has this basis, so
4654
 
                        # we can't use it.
4655
 
                        continue
4656
 
                    if parent_id == _mod_revision.NULL_REVISION:
4657
 
                        parent_inv = null_inventory
4658
 
                    else:
4659
 
                        parent_inv = inventory_cache.get(parent_id, None)
4660
 
                        if parent_inv is None:
4661
 
                            parent_inv = from_repo.get_inventory(parent_id)
4662
 
                    candidate_delta = inv._make_delta(parent_inv)
4663
 
                    if (delta is None or
4664
 
                        len(delta) > len(candidate_delta)):
4665
 
                        delta = candidate_delta
4666
 
                        basis_id = parent_id
4667
 
            if delta is None:
4668
 
                # Either none of the parents ended up being suitable, or we
4669
 
                # were asked to delta against NULL
4670
 
                basis_id = _mod_revision.NULL_REVISION
4671
 
                delta = inv._make_delta(null_inventory)
4672
 
            invs_sent_so_far.add(inv.revision_id)
4673
 
            inventory_cache[inv.revision_id] = inv
4674
 
            delta_serialized = ''.join(
4675
 
                serializer.delta_to_lines(basis_id, key[-1], delta))
4676
 
            yield versionedfile.FulltextContentFactory(
4677
 
                key, parent_keys, None, delta_serialized)
4678
 
 
4679
 
 
4680
 
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
4681
 
                    stop_revision=None):
4682
 
    """Extend the partial history to include a given index
4683
 
 
4684
 
    If a stop_index is supplied, stop when that index has been reached.
4685
 
    If a stop_revision is supplied, stop when that revision is
4686
 
    encountered.  Otherwise, stop when the beginning of history is
4687
 
    reached.
4688
 
 
4689
 
    :param stop_index: The index which should be present.  When it is
4690
 
        present, history extension will stop.
4691
 
    :param stop_revision: The revision id which should be present.  When
4692
 
        it is encountered, history extension will stop.
4693
 
    """
4694
 
    start_revision = partial_history_cache[-1]
4695
 
    iterator = repo.iter_reverse_revision_history(start_revision)
4696
 
    try:
4697
 
        #skip the last revision in the list
4698
 
        iterator.next()
4699
 
        while True:
4700
 
            if (stop_index is not None and
4701
 
                len(partial_history_cache) > stop_index):
4702
 
                break
4703
 
            if partial_history_cache[-1] == stop_revision:
4704
 
                break
4705
 
            revision_id = iterator.next()
4706
 
            partial_history_cache.append(revision_id)
4707
 
    except StopIteration:
4708
 
        # No more history
4709
 
        return
4710