/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: Sabin Iacob
  • Date: 2009-03-23 14:59:43 UTC
  • mto: (4189.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4193.
  • Revision ID: iacobs@m0n5t3r.info-20090323145943-3s3p1px5q1rkh2e5
update FSF mailing address

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
        one_one,
 
61
        one_two,
 
62
        one_six,
 
63
        )
66
64
from bzrlib.trace import (
67
65
    log_exception_quietly, note, mutter, mutter_callsite, warning)
68
66
 
202
200
 
203
201
    def finish_inventory(self):
204
202
        """Tell the builder that the inventory is finished.
205
 
 
 
203
        
206
204
        :return: The inventory id in the repository, which can be used with
207
205
            repository.get_inventory.
208
206
        """
210
208
            # an inventory delta was accumulated without creating a new
211
209
            # inventory.
212
210
            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(
 
211
            self.inv_sha1 = self.repository.add_inventory_by_delta(
217
212
                basis_id, self._basis_delta, self._new_revision_id,
218
213
                self.parents)
219
214
        else:
332
327
            raise AssertionError("recording deletes not activated.")
333
328
        delta = (path, None, file_id, None)
334
329
        self._basis_delta.append(delta)
335
 
        self._any_changes = True
336
330
        return delta
337
331
 
338
332
    def will_record_deletes(self):
473
467
            if content_summary[2] is None:
474
468
                raise ValueError("Files must not have executable = None")
475
469
            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:
 
470
                if (# if the file length changed we have to store:
 
471
                    parent_entry.text_size != content_summary[1] or
 
472
                    # if the exec bit has changed we have to store:
479
473
                    parent_entry.executable != content_summary[2]):
480
474
                    store = True
481
475
                elif parent_entry.text_sha1 == content_summary[3]:
500
494
            ie.executable = content_summary[2]
501
495
            file_obj, stat_value = tree.get_file_with_stat(ie.file_id, path)
502
496
            try:
503
 
                text = file_obj.read()
 
497
                lines = file_obj.readlines()
504
498
            finally:
505
499
                file_obj.close()
506
500
            try:
507
501
                ie.text_sha1, ie.text_size = self._add_text_to_weave(
508
 
                    ie.file_id, text, heads, nostore_sha)
 
502
                    ie.file_id, lines, heads, nostore_sha)
509
503
                # Let the caller know we generated a stat fingerprint.
510
504
                fingerprint = (ie.text_sha1, stat_value)
511
505
            except errors.ExistingContent:
523
517
                # carry over:
524
518
                ie.revision = parent_entry.revision
525
519
                return self._get_delta(ie, basis_inv, path), False, None
526
 
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
520
            lines = []
 
521
            self._add_text_to_weave(ie.file_id, lines, heads, None)
527
522
        elif kind == 'symlink':
528
523
            current_link_target = content_summary[3]
529
524
            if not store:
537
532
                ie.symlink_target = parent_entry.symlink_target
538
533
                return self._get_delta(ie, basis_inv, path), False, None
539
534
            ie.symlink_target = current_link_target
540
 
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
535
            lines = []
 
536
            self._add_text_to_weave(ie.file_id, lines, heads, None)
541
537
        elif kind == 'tree-reference':
542
538
            if not store:
543
539
                if content_summary[3] != parent_entry.reference_revision:
548
544
                ie.revision = parent_entry.revision
549
545
                return self._get_delta(ie, basis_inv, path), False, None
550
546
            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)
 
547
            lines = []
 
548
            self._add_text_to_weave(ie.file_id, lines, heads, None)
555
549
        else:
556
550
            raise NotImplementedError('unknown kind')
557
551
        ie.revision = self._new_revision_id
567
561
            has been generated against. Currently assumed to be the same
568
562
            as self.parents[0] - if it is not, errors may occur.
569
563
        :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.
 
564
            to basis_revision_id.
573
565
        :param _entry_factory: Private method to bind entry_factory locally for
574
566
            performance.
575
 
        :return: A generator of (file_id, relpath, fs_hash) tuples for use with
576
 
            tree._observed_sha1.
 
567
        :return: None
577
568
        """
578
569
        # Create an inventory delta based on deltas between all the parents and
579
570
        # deltas between all the parent inventories. We use inventory delta's 
586
577
        # {file_id -> revision_id -> inventory entry, for entries in parent
587
578
        # trees that are not parents[0]
588
579
        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))
 
580
        revtrees = list(self.repository.revision_trees(self.parents))
604
581
        # The basis inventory from a repository 
605
582
        if revtrees:
606
583
            basis_inv = revtrees[0].inventory
608
585
            basis_inv = self.repository.revision_tree(
609
586
                _mod_revision.NULL_REVISION).inventory
610
587
        if len(self.parents) > 0:
611
 
            if basis_revision_id != self.parents[0] and not ghost_basis:
 
588
            if basis_revision_id != self.parents[0]:
612
589
                raise Exception(
613
590
                    "arbitrary basis parents not yet supported with merges")
614
591
            for revtree in revtrees[1:]:
618
595
                        continue
619
596
                    if change[2] not in merged_ids:
620
597
                        if change[0] is not None:
621
 
                            basis_entry = basis_inv[change[2]]
622
598
                            merged_ids[change[2]] = [
623
 
                                # basis revid
624
 
                                basis_entry.revision,
625
 
                                # new tree revid
 
599
                                basis_inv[change[2]].revision,
626
600
                                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
601
                        else:
634
602
                            merged_ids[change[2]] = [change[3].revision]
635
 
                            parent_entries[change[2]] = {change[3].revision:change[3]}
 
603
                        parent_entries[change[2]] = {change[3].revision:change[3]}
636
604
                    else:
637
605
                        merged_ids[change[2]].append(change[3].revision)
638
606
                        parent_entries[change[2]][change[3].revision] = change[3]
663
631
            # inv delta  change: (file_id, (path_in_source, path_in_target),
664
632
            #   changed_content, versioned, parent, name, kind,
665
633
            #   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])
 
634
            basis_entry = basis_inv[file_id]
 
635
            change = (file_id,
 
636
                (basis_inv.id2path(file_id), tree.id2path(file_id)),
 
637
                False, (True, True),
 
638
                (basis_entry.parent_id, basis_entry.parent_id),
 
639
                (basis_entry.name, basis_entry.name),
 
640
                (basis_entry.kind, basis_entry.kind),
 
641
                (basis_entry.executable, basis_entry.executable))
 
642
            changes[file_id] = (change, merged_ids[file_id])
683
643
        # changes contains tuples with the change and a set of inventory
684
644
        # candidates for the file.
685
645
        # inv delta is:
751
711
                        entry.executable = True
752
712
                    else:
753
713
                        entry.executable = False
754
 
                    if (carry_over_possible and
 
714
                    if (carry_over_possible and 
755
715
                        parent_entry.executable == entry.executable):
756
716
                            # Check the file length, content hash after reading
757
717
                            # the file.
760
720
                        nostore_sha = None
761
721
                    file_obj, stat_value = tree.get_file_with_stat(file_id, change[1][1])
762
722
                    try:
763
 
                        text = file_obj.read()
 
723
                        lines = file_obj.readlines()
764
724
                    finally:
765
725
                        file_obj.close()
766
726
                    try:
767
727
                        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)
 
728
                            file_id, lines, heads, nostore_sha)
770
729
                    except errors.ExistingContent:
771
730
                        # No content change against a carry_over parent
772
 
                        # Perhaps this should also yield a fs hash update?
773
731
                        carried_over = True
774
732
                        entry.text_size = parent_entry.text_size
775
733
                        entry.text_sha1 = parent_entry.text_sha1
778
736
                    entry.symlink_target = tree.get_symlink_target(file_id)
779
737
                    if (carry_over_possible and
780
738
                        parent_entry.symlink_target == entry.symlink_target):
781
 
                        carried_over = True
 
739
                            carried_over = True
782
740
                    else:
783
 
                        self._add_text_to_weave(change[0], '', heads, None)
 
741
                        self._add_text_to_weave(change[0], [], heads, None)
784
742
                elif kind == 'directory':
785
743
                    if carry_over_possible:
786
744
                        carried_over = True
788
746
                        # Nothing to set on the entry.
789
747
                        # XXX: split into the Root and nonRoot versions.
790
748
                        if change[1][1] != '' or self.repository.supports_rich_root():
791
 
                            self._add_text_to_weave(change[0], '', heads, None)
 
749
                            self._add_text_to_weave(change[0], [], heads, None)
792
750
                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)
 
751
                    raise AssertionError('unknown kind %r' % kind)
807
752
                else:
808
753
                    raise AssertionError('unknown kind %r' % kind)
809
754
                if not carried_over:
818
763
                seen_root = True
819
764
        self.new_inventory = None
820
765
        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
766
            self._any_changes = True
825
767
        if not seen_root:
826
768
            # housekeeping root entry changes do not affect no-change commits.
827
769
            self._require_root_change(tree)
828
770
        self.basis_delta_revision = basis_revision_id
829
771
 
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]
 
772
    def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):
 
773
        # Note: as we read the content directly from the tree, we know its not
 
774
        # been turned into unicode or badly split - but a broken tree
 
775
        # implementation could give us bad output from readlines() so this is
 
776
        # not a guarantee of safety. What would be better is always checking
 
777
        # the content during test suite execution. RBC 20070912
 
778
        parent_keys = tuple((file_id, parent) for parent in parents)
 
779
        return self.repository.texts.add_lines(
 
780
            (file_id, self._new_revision_id), parent_keys, new_lines,
 
781
            nostore_sha=nostore_sha, random_id=self.random_revid,
 
782
            check_content=False)[0:2]
835
783
 
836
784
 
837
785
class RootCommitBuilder(CommitBuilder):
863
811
######################################################################
864
812
# Repositories
865
813
 
866
 
 
867
 
class Repository(_RelockDebugMixin, bzrdir.ControlComponent):
 
814
class Repository(object):
868
815
    """Repository holding history for one or more branches.
869
816
 
870
817
    The repository holds and retrieves historical information including
872
819
    which views a particular line of development through that history.
873
820
 
874
821
    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
 
822
    signatures, inventories and texts attributes) and a Transport, which
 
823
    respectively provide byte storage and a means to access the (possibly
877
824
    remote) disk.
878
825
 
879
826
    The byte storage facilities are addressed via tuples, which we refer to
880
827
    as 'keys' throughout the code base. Revision_keys, inventory_keys and
881
828
    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.
 
829
    (file_id, revision_id). We use this interface because it allows low
 
830
    friction with the underlying code that implements disk indices, network
 
831
    encoding and other parts of bzrlib.
887
832
 
888
833
    :ivar revisions: A bzrlib.versionedfile.VersionedFiles instance containing
889
834
        the serialised revisions for the repository. This can be used to obtain
908
853
        The result of trying to insert data into the repository via this store
909
854
        is undefined: it should be considered read-only except for implementors
910
855
        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
856
    :ivar _transport: Transport for file access to repository, typically
917
857
        pointing to .bzr/repository.
918
858
    """
939
879
        """
940
880
        if self._write_group is not self.get_transaction():
941
881
            # 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()))
 
882
            raise errors.BzrError('mismatched lock context and write group.')
950
883
        try:
951
884
            self._abort_write_group()
952
885
        except Exception, exc:
978
911
        """
979
912
        if not self._format.supports_external_lookups:
980
913
            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
914
        self._check_fallback_repository(repository)
986
915
        self._fallback_repositories.append(repository)
987
916
        self.texts.add_fallback_versioned_files(repository.texts)
988
917
        self.inventories.add_fallback_versioned_files(repository.inventories)
989
918
        self.revisions.add_fallback_versioned_files(repository.revisions)
990
919
        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
920
 
994
921
    def _check_fallback_repository(self, repository):
995
922
        """Check that this repository can fallback to repository safely.
1019
946
                % (inv.revision_id, revision_id))
1020
947
        if inv.root is None:
1021
948
            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)
 
949
        inv_lines = self._serialise_inventory_to_lines(inv)
1032
950
        return self._inventory_add_lines(revision_id, parents,
1033
951
            inv_lines, check_content=False)
1034
952
 
1035
953
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
1036
 
                               parents, basis_inv=None, propagate_caches=False):
 
954
                               parents):
1037
955
        """Add a new inventory expressed as a delta against another revision.
1038
956
 
1039
 
        See the inventory developers documentation for the theory behind
1040
 
        inventory deltas.
1041
 
 
1042
957
        :param basis_revision_id: The inventory id the delta was created
1043
958
            against. (This does not have to be a direct parent.)
1044
959
        :param delta: The inventory delta (see Inventory.apply_delta for
1050
965
            for repositories that depend on the inventory graph for revision
1051
966
            graph access, as well as for those that pun ancestry with delta
1052
967
            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
968
 
1058
969
        :returns: (validator, new_inv)
1059
970
            The validator(which is a sha1 digest, though what is sha'd is
1070
981
            # inventory implementations may support: A better idiom would be to
1071
982
            # return a new inventory, but as there is no revision tree cache in
1072
983
            # repository this is safe for now - RBC 20081013
1073
 
            if basis_inv is None:
1074
 
                basis_inv = basis_tree.inventory
 
984
            basis_inv = basis_tree.inventory
1075
985
            basis_inv.apply_delta(delta)
1076
986
            basis_inv.revision_id = new_revision_id
1077
987
            return (self.add_inventory(new_revision_id, basis_inv, parents),
1083
993
        check_content=True):
1084
994
        """Store lines in inv_vf and return the sha1 of the inventory."""
1085
995
        parents = [(parent,) for parent in parents]
1086
 
        result = self.inventories.add_lines((revision_id,), parents, lines,
 
996
        return self.inventories.add_lines((revision_id,), parents, lines,
1087
997
            check_content=check_content)[0]
1088
 
        self.inventories._access.flush()
1089
 
        return result
1090
998
 
1091
999
    def add_revision(self, revision_id, rev, inv=None, config=None):
1092
1000
        """Add rev to the revision store as revision_id.
1168
1076
        # The old API returned a list, should this actually be a set?
1169
1077
        return parent_map.keys()
1170
1078
 
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
1079
    @staticmethod
1285
1080
    def create(a_bzrdir):
1286
1081
        """Construct the current default format repository in a_bzrdir."""
1291
1086
 
1292
1087
        :param _format: The format of the repository on disk.
1293
1088
        :param a_bzrdir: The BzrDir of the repository.
 
1089
 
 
1090
        In the future we will have a single api for all stores for
 
1091
        getting file texts, inventories and revisions, then
 
1092
        this construct will accept instances of those things.
1294
1093
        """
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
1094
        super(Repository, self).__init__()
1299
1095
        self._format = _format
1300
1096
        # the following are part of the public API for Repository:
1306
1102
        self._reconcile_does_inventory_gc = True
1307
1103
        self._reconcile_fixes_text_parents = False
1308
1104
        self._reconcile_backsup_inventory = True
 
1105
        # not right yet - should be more semantically clear ?
 
1106
        #
 
1107
        # TODO: make sure to construct the right store classes, etc, depending
 
1108
        # on whether escaping is required.
 
1109
        self._warn_if_deprecated()
1309
1110
        self._write_group = None
1310
1111
        # Additional places to query for data.
1311
1112
        self._fallback_repositories = []
1312
1113
        # An InventoryEntry cache, used during deserialization
1313
1114
        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
1115
 
1326
1116
    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
 
1117
        return '%s(%r)' % (self.__class__.__name__,
 
1118
                           self.base)
1346
1119
 
1347
1120
    def has_same_location(self, other):
1348
1121
        """Returns a boolean indicating if this repository is at the same
1393
1166
        """
1394
1167
        locked = self.is_locked()
1395
1168
        result = self.control_files.lock_write(token=token)
 
1169
        for repo in self._fallback_repositories:
 
1170
            # Writes don't affect fallback repos
 
1171
            repo.lock_read()
1396
1172
        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
1173
            self._refresh_data()
1403
1174
        return result
1404
1175
 
1405
1176
    def lock_read(self):
1406
1177
        locked = self.is_locked()
1407
1178
        self.control_files.lock_read()
 
1179
        for repo in self._fallback_repositories:
 
1180
            repo.lock_read()
1408
1181
        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
1182
            self._refresh_data()
1414
1183
 
1415
1184
    def get_physical_lock_status(self):
1476
1245
 
1477
1246
        # now gather global repository information
1478
1247
        # XXX: This is available for many repos regardless of listability.
1479
 
        if self.user_transport.listable():
 
1248
        if self.bzrdir.root_transport.listable():
1480
1249
            # XXX: do we want to __define len__() ?
1481
1250
            # Maybe the versionedfiles object should provide a different
1482
1251
            # method to get the number of keys.
1492
1261
        :param using: If True, list only branches using this repository.
1493
1262
        """
1494
1263
        if using and not self.is_shared():
1495
 
            return self.bzrdir.list_branches()
 
1264
            try:
 
1265
                return [self.bzrdir.open_branch()]
 
1266
            except errors.NotBranchError:
 
1267
                return []
1496
1268
        class Evaluator(object):
1497
1269
 
1498
1270
            def __init__(self):
1507
1279
                    except errors.NoRepositoryPresent:
1508
1280
                        pass
1509
1281
                    else:
1510
 
                        return False, ([], repository)
 
1282
                        return False, (None, repository)
1511
1283
                self.first_call = False
1512
 
                value = (bzrdir.list_branches(), None)
 
1284
                try:
 
1285
                    value = (bzrdir.open_branch(), None)
 
1286
                except errors.NotBranchError:
 
1287
                    value = (None, None)
1513
1288
                return True, value
1514
1289
 
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)
 
1290
        branches = []
 
1291
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
1292
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
1293
            if branch is not None:
 
1294
                branches.append(branch)
1520
1295
            if not using and repository is not None:
1521
 
                ret.extend(repository.find_branches())
1522
 
        return ret
 
1296
                branches.extend(repository.find_branches())
 
1297
        return branches
1523
1298
 
1524
1299
    @needs_read_lock
1525
1300
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
1532
1307
        return InterRepository.get(other, self).search_missing_revision_ids(
1533
1308
            revision_id, find_ghosts)
1534
1309
 
 
1310
    @deprecated_method(one_two)
 
1311
    @needs_read_lock
 
1312
    def missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
1313
        """Return the revision ids that other has that this does not.
 
1314
 
 
1315
        These are returned in topological order.
 
1316
 
 
1317
        revision_id: only return revision ids included by revision_id.
 
1318
        """
 
1319
        keys =  self.search_missing_revision_ids(
 
1320
            other, revision_id, find_ghosts).get_keys()
 
1321
        other.lock_read()
 
1322
        try:
 
1323
            parents = other.get_graph().get_parent_map(keys)
 
1324
        finally:
 
1325
            other.unlock()
 
1326
        return tsort.topo_sort(parents)
 
1327
 
1535
1328
    @staticmethod
1536
1329
    def open(base):
1537
1330
        """Open the repository rooted at base.
1554
1347
        """Commit the contents accrued within the current write group.
1555
1348
 
1556
1349
        :seealso: start_write_group.
1557
 
        
1558
 
        :return: it may return an opaque hint that can be passed to 'pack'.
1559
1350
        """
1560
1351
        if self._write_group is not self.get_transaction():
1561
1352
            # has an unlock or relock occured ?
1562
1353
            raise errors.BzrError('mismatched lock context %r and '
1563
1354
                'write group %r.' %
1564
1355
                (self.get_transaction(), self._write_group))
1565
 
        result = self._commit_write_group()
 
1356
        self._commit_write_group()
1566
1357
        self._write_group = None
1567
 
        return result
1568
1358
 
1569
1359
    def _commit_write_group(self):
1570
1360
        """Template method for per-repository write group cleanup.
1578
1368
    def suspend_write_group(self):
1579
1369
        raise errors.UnsuspendableWriteGroup(self)
1580
1370
 
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
1371
    def refresh_data(self):
1637
1372
        """Re-read any data needed to to synchronise with disk.
1638
1373
 
1687
1422
            raise errors.InternalBzrError(
1688
1423
                "May not fetch while in a write group.")
1689
1424
        # 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)):
 
1425
        if self.has_same_location(source) and fetch_spec is None:
1695
1426
            # check that last_revision is in 'from' and then return a
1696
1427
            # no-operation.
1697
1428
            if (revision_id is not None and
1722
1453
        :param revprops: Optional dictionary of revision properties.
1723
1454
        :param revision_id: Optional revision id.
1724
1455
        """
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
1456
        result = self._commit_builder_class(self, parents, config,
1730
1457
            timestamp, timezone, committer, revprops, revision_id)
1731
1458
        self.start_write_group()
1732
1459
        return result
1733
1460
 
1734
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1735
1461
    def unlock(self):
1736
1462
        if (self.control_files._lock_count == 1 and
1737
1463
            self.control_files._lock_mode == 'w'):
1743
1469
        self.control_files.unlock()
1744
1470
        if self.control_files._lock_count == 0:
1745
1471
            self._inventory_entry_cache.clear()
1746
 
            for repo in self._fallback_repositories:
1747
 
                repo.unlock()
 
1472
        for repo in self._fallback_repositories:
 
1473
            repo.unlock()
1748
1474
 
1749
1475
    @needs_read_lock
1750
1476
    def clone(self, a_bzrdir, revision_id=None):
1859
1585
 
1860
1586
    @needs_read_lock
1861
1587
    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
 
        """
 
1588
        """Get many revisions at once."""
1867
1589
        return self._get_revisions(revision_ids)
1868
1590
 
1869
1591
    @needs_read_lock
1870
1592
    def _get_revisions(self, revision_ids):
1871
1593
        """Core work logic to get many revisions without sanity checks."""
 
1594
        for rev_id in revision_ids:
 
1595
            if not rev_id or not isinstance(rev_id, basestring):
 
1596
                raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
 
1597
        keys = [(key,) for key in revision_ids]
 
1598
        stream = self.revisions.get_record_stream(keys, 'unordered', True)
1872
1599
        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
 
1600
        for record in stream:
 
1601
            if record.storage_kind == 'absent':
 
1602
                raise errors.NoSuchRevision(self, record.key[0])
 
1603
            text = record.get_bytes_as('fulltext')
 
1604
            rev = self._serializer.read_revision_from_string(text)
 
1605
            revs[record.key[0]] = rev
1877
1606
        return [revs[revid] for revid in revision_ids]
1878
1607
 
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)
 
1608
    @needs_read_lock
 
1609
    def get_revision_xml(self, revision_id):
 
1610
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1611
        #       would have already do it.
 
1612
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1613
        rev = self.get_revision(revision_id)
 
1614
        rev_tmp = cStringIO.StringIO()
 
1615
        # the current serializer..
 
1616
        self._serializer.write_revision(rev, rev_tmp)
 
1617
        rev_tmp.seek(0)
 
1618
        return rev_tmp.getvalue()
1905
1619
 
1906
1620
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
1907
1621
        """Produce a generator of revision deltas.
2085
1799
                    yield line, revid
2086
1800
 
2087
1801
    def _find_file_ids_from_xml_inventory_lines(self, line_iterator,
2088
 
        revision_keys):
 
1802
        revision_ids):
2089
1803
        """Helper routine for fileids_altered_by_revision_ids.
2090
1804
 
2091
1805
        This performs the translation of xml lines to revision ids.
2092
1806
 
2093
1807
        :param line_iterator: An iterator of lines, origin_version_id
2094
 
        :param revision_keys: The revision ids to filter for. This should be a
 
1808
        :param revision_ids: The revision ids to filter for. This should be a
2095
1809
            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.
 
1810
            the revision id from each parsed line will be looked up in the
 
1811
            revision_ids filter.
2098
1812
        :return: a dictionary mapping altered file-ids to an iterable of
2099
1813
        revision_ids. Each altered file-ids has the exact revision_ids that
2100
1814
        altered it listed explicitly.
2101
1815
        """
2102
1816
        seen = set(self._find_text_key_references_from_xml_inventory_lines(
2103
1817
                line_iterator).iterkeys())
2104
 
        parent_keys = self._find_parent_keys_of_revisions(revision_keys)
 
1818
        # Note that revision_ids are revision keys.
 
1819
        parent_maps = self.revisions.get_parent_map(revision_ids)
 
1820
        parents = set()
 
1821
        map(parents.update, parent_maps.itervalues())
 
1822
        parents.difference_update(revision_ids)
2105
1823
        parent_seen = set(self._find_text_key_references_from_xml_inventory_lines(
2106
 
            self._inventory_xml_lines_for_keys(parent_keys)))
 
1824
            self._inventory_xml_lines_for_keys(parents)))
2107
1825
        new_keys = seen - parent_seen
2108
1826
        result = {}
2109
1827
        setdefault = result.setdefault
2111
1829
            setdefault(key[0], set()).add(key[-1])
2112
1830
        return result
2113
1831
 
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
1832
    def fileids_altered_by_revision_ids(self, revision_ids, _inv_weave=None):
2142
1833
        """Find the file ids and versions affected by revisions.
2143
1834
 
2150
1841
        """
2151
1842
        selected_keys = set((revid,) for revid in revision_ids)
2152
1843
        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)
 
1844
        pb = ui.ui_factory.nested_progress_bar()
 
1845
        try:
 
1846
            return self._find_file_ids_from_xml_inventory_lines(
 
1847
                w.iter_lines_added_or_present_in_keys(
 
1848
                    selected_keys, pb=pb),
 
1849
                selected_keys)
 
1850
        finally:
 
1851
            pb.finished()
2157
1852
 
2158
1853
    def iter_files_bytes(self, desired_files):
2159
1854
        """Iterate through file versions.
2180
1875
        for record in self.texts.get_record_stream(text_keys, 'unordered', True):
2181
1876
            if record.storage_kind == 'absent':
2182
1877
                raise errors.RevisionNotPresent(record.key, self)
2183
 
            yield text_keys[record.key], record.get_bytes_as('chunked')
 
1878
            yield text_keys[record.key], record.get_bytes_as('fulltext')
2184
1879
 
2185
1880
    def _generate_text_key_index(self, text_key_references=None,
2186
1881
        ancestors=None):
2241
1936
                batch_size]
2242
1937
            if not to_query:
2243
1938
                break
2244
 
            for revision_id in to_query:
 
1939
            for rev_tree in self.revision_trees(to_query):
 
1940
                revision_id = rev_tree.get_revision_id()
2245
1941
                parent_ids = ancestors[revision_id]
2246
1942
                for text_key in revision_keys[revision_id]:
2247
1943
                    pb.update("Calculating text parents", processed_texts)
2266
1962
                            except KeyError:
2267
1963
                                inv = self.revision_tree(parent_id).inventory
2268
1964
                                inventory_cache[parent_id] = inv
2269
 
                            try:
2270
 
                                parent_entry = inv[text_key[0]]
2271
 
                            except (KeyError, errors.NoSuchId):
2272
 
                                parent_entry = None
 
1965
                            parent_entry = inv._byid.get(text_key[0], None)
2273
1966
                            if parent_entry is not None:
2274
1967
                                parent_text_key = (
2275
1968
                                    text_key[0], parent_entry.revision)
2300
1993
            versions).  knit-kind is one of 'file', 'inventory', 'signatures',
2301
1994
            'revisions'.  file-id is None unless knit-kind is 'file'.
2302
1995
        """
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
1996
        # XXX: it's a bit weird to control the inventory weave caching in this
2311
1997
        # generator.  Ideally the caching would be done in fetch.py I think.  Or
2312
1998
        # maybe this generator should explicitly have the contract that it
2319
2005
        count = 0
2320
2006
        num_file_ids = len(file_ids)
2321
2007
        for file_id, altered_versions in file_ids.iteritems():
2322
 
            if pb is not None:
2323
 
                pb.update("Fetch texts", count, num_file_ids)
 
2008
            if _files_pb is not None:
 
2009
                _files_pb.update("fetch texts", count, num_file_ids)
2324
2010
            count += 1
2325
2011
            yield ("file", file_id, altered_versions)
 
2012
        # We're done with the files_pb.  Note that it finished by the caller,
 
2013
        # just as it was created by the caller.
 
2014
        del _files_pb
2326
2015
 
2327
 
    def _find_non_file_keys_to_fetch(self, revision_ids):
2328
2016
        # inventory
2329
2017
        yield ("inventory", None, revision_ids)
2330
2018
 
2347
2035
        """Get Inventory object by revision id."""
2348
2036
        return self.iter_inventories([revision_id]).next()
2349
2037
 
2350
 
    def iter_inventories(self, revision_ids, ordering=None):
 
2038
    def iter_inventories(self, revision_ids):
2351
2039
        """Get many inventories by revision_ids.
2352
2040
 
2353
2041
        This will buffer some or all of the texts used in constructing the
2354
2042
        inventories in memory, but will only parse a single inventory at a
2355
2043
        time.
2356
2044
 
2357
 
        :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
2045
        :return: An iterator of inventories.
2362
2046
        """
2363
2047
        if ((None in revision_ids)
2364
2048
            or (_mod_revision.NULL_REVISION in revision_ids)):
2365
2049
            raise ValueError('cannot get null revision inventory')
2366
 
        return self._iter_inventories(revision_ids, ordering)
 
2050
        return self._iter_inventories(revision_ids)
2367
2051
 
2368
 
    def _iter_inventories(self, revision_ids, ordering):
 
2052
    def _iter_inventories(self, revision_ids):
2369
2053
        """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)
 
2054
        for text, revision_id in self._iter_inventory_xmls(revision_ids):
 
2055
            yield self.deserialise_inventory(revision_id, text)
2373
2056
 
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
 
2057
    def _iter_inventory_xmls(self, revision_ids):
2380
2058
        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)
 
2059
        stream = self.inventories.get_record_stream(keys, 'unordered', True)
2387
2060
        text_chunks = {}
2388
2061
        for record in stream:
2389
2062
            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]
 
2063
                text_chunks[record.key] = record.get_bytes_as('chunked')
2395
2064
            else:
2396
2065
                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
 
2066
        for key in keys:
 
2067
            chunks = text_chunks.pop(key)
 
2068
            yield ''.join(chunks), key[-1]
2409
2069
 
2410
 
    def _deserialise_inventory(self, revision_id, xml):
 
2070
    def deserialise_inventory(self, revision_id, xml):
2411
2071
        """Transform the xml into an inventory object.
2412
2072
 
2413
2073
        :param revision_id: The expected revision id of the inventory.
2414
2074
        :param xml: A serialised inventory.
2415
2075
        """
2416
2076
        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)
 
2077
                    entry_cache=self._inventory_entry_cache)
2419
2078
        if result.revision_id != revision_id:
2420
2079
            raise AssertionError('revision id mismatch %s != %s' % (
2421
2080
                result.revision_id, revision_id))
2422
2081
        return result
2423
2082
 
 
2083
    def serialise_inventory(self, inv):
 
2084
        return self._serializer.write_inventory_to_string(inv)
 
2085
 
 
2086
    def _serialise_inventory_to_lines(self, inv):
 
2087
        return self._serializer.write_inventory_to_lines(inv)
 
2088
 
2424
2089
    def get_serializer_format(self):
2425
2090
        return self._serializer.format_num
2426
2091
 
2427
2092
    @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')
 
2093
    def get_inventory_xml(self, revision_id):
 
2094
        """Get inventory XML as a file object."""
 
2095
        texts = self._iter_inventory_xmls([revision_id])
2431
2096
        try:
2432
2097
            text, revision_id = texts.next()
2433
2098
        except StopIteration:
2434
2099
            raise errors.HistoryMissing(self, 'inventory', revision_id)
2435
2100
        return text
2436
2101
 
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)).
 
2102
    @needs_read_lock
 
2103
    def get_inventory_sha1(self, revision_id):
 
2104
        """Return the sha1 hash of the inventory entry
2444
2105
        """
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])
 
2106
        return self.get_revision(revision_id).inventory_sha1
2471
2107
 
2472
2108
    def iter_reverse_revision_history(self, revision_id):
2473
2109
        """Iterate backwards through revision ids in the lefthand history
2480
2116
        while True:
2481
2117
            if next_id in (None, _mod_revision.NULL_REVISION):
2482
2118
                return
2483
 
            try:
2484
 
                parents = graph.get_parent_map([next_id])[next_id]
2485
 
            except KeyError:
2486
 
                raise errors.RevisionNotPresent(next_id, self)
2487
2119
            yield next_id
 
2120
            # Note: The following line may raise KeyError in the event of
 
2121
            # truncated history. We decided not to have a try:except:raise
 
2122
            # RevisionNotPresent here until we see a use for it, because of the
 
2123
            # cost in an inner loop that is by its very nature O(history).
 
2124
            # Robert Collins 20080326
 
2125
            parents = graph.get_parent_map([next_id])[next_id]
2488
2126
            if len(parents) == 0:
2489
2127
                return
2490
2128
            else:
2491
2129
                next_id = parents[0]
2492
2130
 
 
2131
    @needs_read_lock
 
2132
    def get_revision_inventory(self, revision_id):
 
2133
        """Return inventory of a past revision."""
 
2134
        # TODO: Unify this with get_inventory()
 
2135
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
2136
        # must be the same as its revision, so this is trivial.
 
2137
        if revision_id is None:
 
2138
            # This does not make sense: if there is no revision,
 
2139
            # then it is the current tree inventory surely ?!
 
2140
            # and thus get_root_id() is something that looks at the last
 
2141
            # commit on the branch, and the get_root_id is an inventory check.
 
2142
            raise NotImplementedError
 
2143
            # return Inventory(self.get_root_id())
 
2144
        else:
 
2145
            return self.get_inventory(revision_id)
 
2146
 
2493
2147
    def is_shared(self):
2494
2148
        """Return True if this repository is flagged as a shared repository."""
2495
2149
        raise NotImplementedError(self.is_shared)
2529
2183
            return RevisionTree(self, Inventory(root_id=None),
2530
2184
                                _mod_revision.NULL_REVISION)
2531
2185
        else:
2532
 
            inv = self.get_inventory(revision_id)
 
2186
            inv = self.get_revision_inventory(revision_id)
2533
2187
            return RevisionTree(self, inv, revision_id)
2534
2188
 
2535
2189
    def revision_trees(self, revision_ids):
2588
2242
            keys = tsort.topo_sort(parent_map)
2589
2243
        return [None] + list(keys)
2590
2244
 
2591
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2245
    def pack(self):
2592
2246
        """Compress the data within the repository.
2593
2247
 
2594
2248
        This operation only makes sense for some repository types. For other
2597
2251
        This stub method does not require a lock, but subclasses should use
2598
2252
        @needs_write_lock as this is a long running call its reasonable to
2599
2253
        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
 
        """
 
2254
        """
 
2255
 
 
2256
    @needs_read_lock
 
2257
    @deprecated_method(one_six)
 
2258
    def print_file(self, file, revision_id):
 
2259
        """Print `file` to stdout.
 
2260
 
 
2261
        FIXME RBC 20060125 as John Meinel points out this is a bad api
 
2262
        - it writes to stdout, it assumes that that is valid etc. Fix
 
2263
        by creating a new more flexible convenience function.
 
2264
        """
 
2265
        tree = self.revision_tree(revision_id)
 
2266
        # use inventory as it was in that revision
 
2267
        file_id = tree.inventory.path2id(file)
 
2268
        if not file_id:
 
2269
            # TODO: jam 20060427 Write a test for this code path
 
2270
            #       it had a bug in it, and was raising the wrong
 
2271
            #       exception.
 
2272
            raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
 
2273
        tree.print_file(file_id)
2611
2274
 
2612
2275
    def get_transaction(self):
2613
2276
        return self.control_files.get_transaction()
2614
2277
 
 
2278
    @deprecated_method(one_one)
 
2279
    def get_parents(self, revision_ids):
 
2280
        """See StackedParentsProvider.get_parents"""
 
2281
        parent_map = self.get_parent_map(revision_ids)
 
2282
        return [parent_map.get(r, None) for r in revision_ids]
 
2283
 
2615
2284
    def get_parent_map(self, revision_ids):
2616
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
2285
        """See graph._StackedParentsProvider.get_parent_map"""
2617
2286
        # revisions index works in keys; this just works in revisions
2618
2287
        # therefore wrap and unwrap
2619
2288
        query_keys = []
2628
2297
        for ((revision_id,), parent_keys) in \
2629
2298
                self.revisions.get_parent_map(query_keys).iteritems():
2630
2299
            if parent_keys:
2631
 
                result[revision_id] = tuple([parent_revid
2632
 
                    for (parent_revid,) in parent_keys])
 
2300
                result[revision_id] = tuple(parent_revid
 
2301
                    for (parent_revid,) in parent_keys)
2633
2302
            else:
2634
2303
                result[revision_id] = (_mod_revision.NULL_REVISION,)
2635
2304
        return result
2637
2306
    def _make_parents_provider(self):
2638
2307
        return self
2639
2308
 
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
2309
    def get_graph(self, other_repository=None):
2650
2310
        """Return the graph walker for this repository format"""
2651
2311
        parents_provider = self._make_parents_provider()
2652
2312
        if (other_repository is not None and
2653
2313
            not self.has_same_location(other_repository)):
2654
 
            parents_provider = graph.StackedParentsProvider(
 
2314
            parents_provider = graph._StackedParentsProvider(
2655
2315
                [parents_provider, other_repository._make_parents_provider()])
2656
2316
        return graph.Graph(parents_provider)
2657
2317
 
2658
 
    def _get_versioned_file_checker(self, text_key_references=None,
2659
 
        ancestors=None):
 
2318
    def _get_versioned_file_checker(self, text_key_references=None):
2660
2319
        """Return an object suitable for checking versioned files.
2661
2320
        
2662
2321
        :param text_key_references: if non-None, an already built
2664
2323
            to whether they were referred to by the inventory of the
2665
2324
            revision_id that they contain. If None, this will be
2666
2325
            calculated.
2667
 
        :param ancestors: Optional result from
2668
 
            self.get_graph().get_parent_map(self.all_revision_ids()) if already
2669
 
            available.
2670
2326
        """
2671
2327
        return _VersionedFileChecker(self,
2672
 
            text_key_references=text_key_references, ancestors=ancestors)
 
2328
            text_key_references=text_key_references)
2673
2329
 
2674
2330
    def revision_ids_to_search_result(self, result_set):
2675
2331
        """Convert a set of revision ids to a graph SearchResult."""
2725
2381
        return record.get_bytes_as('fulltext')
2726
2382
 
2727
2383
    @needs_read_lock
2728
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
2384
    def check(self, revision_ids=None):
2729
2385
        """Check consistency of all history of given revision_ids.
2730
2386
 
2731
2387
        Different repository implementations should override _check().
2732
2388
 
2733
2389
        :param revision_ids: A non-empty list of revision_ids whose ancestry
2734
2390
             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
2391
        """
2741
 
        return self._check(revision_ids, callback_refs=callback_refs,
2742
 
            check_repo=check_repo)
 
2392
        return self._check(revision_ids)
2743
2393
 
2744
 
    def _check(self, revision_ids, callback_refs, check_repo):
2745
 
        result = check.Check(self, check_repo=check_repo)
2746
 
        result.check(callback_refs)
 
2394
    def _check(self, revision_ids):
 
2395
        result = check.Check(self)
 
2396
        result.check()
2747
2397
        return result
2748
2398
 
2749
 
    def _warn_if_deprecated(self, branch=None):
 
2399
    def _warn_if_deprecated(self):
2750
2400
        global _deprecation_warning_done
2751
2401
        if _deprecation_warning_done:
2752
2402
            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
 
2403
        _deprecation_warning_done = True
 
2404
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
2405
                % (self._format, self.bzrdir.transport.base))
2765
2406
 
2766
2407
    def supports_rich_root(self):
2767
2408
        return self._format.rich_root_data
2841
2482
    """
2842
2483
    repository.start_write_group()
2843
2484
    try:
2844
 
        inventory_cache = lru_cache.LRUCache(10)
2845
2485
        for n, (revision, revision_tree, signature) in enumerate(iterable):
2846
 
            _install_revision(repository, revision, revision_tree, signature,
2847
 
                inventory_cache)
 
2486
            _install_revision(repository, revision, revision_tree, signature)
2848
2487
            if pb is not None:
2849
2488
                pb.update('Transferring revisions', n + 1, num_revisions)
2850
2489
    except:
2854
2493
        repository.commit_write_group()
2855
2494
 
2856
2495
 
2857
 
def _install_revision(repository, rev, revision_tree, signature,
2858
 
    inventory_cache):
 
2496
def _install_revision(repository, rev, revision_tree, signature):
2859
2497
    """Install all revision data into a repository."""
2860
2498
    present_parents = []
2861
2499
    parent_trees = {}
2898
2536
        repository.texts.add_lines(text_key, text_parents, lines)
2899
2537
    try:
2900
2538
        # 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)
 
2539
        repository.add_inventory(rev.revision_id, inv, present_parents)
2914
2540
    except errors.RevisionAlreadyPresent:
2915
2541
        pass
2916
2542
    if signature is not None:
3007
2633
 
3008
2634
    Once a format is deprecated, just deprecate the initialize and open
3009
2635
    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
 
2636
    object may be created even when a repository instnace hasn't been
3011
2637
    created.
3012
2638
 
3013
2639
    Common instance attributes:
3023
2649
    # Can this repository be given external locations to lookup additional
3024
2650
    # data. Set to True or False in derived classes.
3025
2651
    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
2652
    # What order should fetch operations request streams in?
3032
2653
    # The default is unordered as that is the cheapest for an origin to
3033
2654
    # provide.
3040
2661
    # Should fetch trigger a reconcile after the fetch? Only needed for
3041
2662
    # some repository formats that can suffer internal inconsistencies.
3042
2663
    _fetch_reconcile = False
3043
 
    # Does this format have < O(tree_size) delta generation. Used to hint what
3044
 
    # code path for commit, amongst other things.
3045
 
    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
2664
 
3056
 
    def __repr__(self):
3057
 
        return "%s()" % self.__class__.__name__
 
2665
    def __str__(self):
 
2666
        return "<%s>" % self.__class__.__name__
3058
2667
 
3059
2668
    def __eq__(self, other):
3060
2669
        # format objects are generally stateless
3073
2682
        """
3074
2683
        try:
3075
2684
            transport = a_bzrdir.get_repository_transport(None)
3076
 
            format_string = transport.get_bytes("format")
 
2685
            format_string = transport.get("format").read()
3077
2686
            return format_registry.get(format_string)
3078
2687
        except errors.NoSuchFile:
3079
2688
            raise errors.NoRepositoryPresent(a_bzrdir)
3161
2770
        raise NotImplementedError(self.network_name)
3162
2771
 
3163
2772
    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)
 
2773
        raise NotImplementedError(self.check_conversion_target)
3173
2774
 
3174
2775
    def open(self, a_bzrdir, _found=False):
3175
2776
        """Return an instance of this format for the bzrdir a_bzrdir.
3178
2779
        """
3179
2780
        raise NotImplementedError(self.open)
3180
2781
 
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
2782
 
3191
2783
class MetaDirRepositoryFormat(RepositoryFormat):
3192
2784
    """Common base class for the new repositories using the metadir layout."""
3240
2832
# Pre-0.8 formats that don't have a disk format string (because they are
3241
2833
# versioned by the matching control directory). We use the control directories
3242
2834
# disk format string as a key for the network_name because they meet the
3243
 
# constraints (simple string, unique, immutable).
 
2835
# constraints (simple string, unique, immmutable).
3244
2836
network_format_registry.register_lazy(
3245
2837
    "Bazaar-NG branch, format 5\n",
3246
2838
    'bzrlib.repofmt.weaverepo',
3327
2919
    )
3328
2920
 
3329
2921
# Development formats.
3330
 
# Obsolete but kept pending a CHK based subtree format.
 
2922
# 1.7->1.8 go below here
 
2923
format_registry.register_lazy(
 
2924
    "Bazaar development format 2 (needs bzr.dev from before 1.8)\n",
 
2925
    'bzrlib.repofmt.pack_repo',
 
2926
    'RepositoryFormatPackDevelopment2',
 
2927
    )
3331
2928
format_registry.register_lazy(
3332
2929
    ("Bazaar development format 2 with subtree support "
3333
2930
        "(needs bzr.dev from before 1.8)\n"),
3335
2932
    'RepositoryFormatPackDevelopment2Subtree',
3336
2933
    )
3337
2934
 
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
2935
 
3359
2936
class InterRepository(InterObject):
3360
2937
    """This class represents operations taking place between two repositories.
3397
2974
 
3398
2975
        :param revision_id: if None all content is copied, if NULL_REVISION no
3399
2976
                            content is copied.
3400
 
        :param pb: ignored.
 
2977
        :param pb: optional progress bar to use for progress reports. If not
 
2978
                   provided a default one will be created.
3401
2979
        :return: None.
3402
2980
        """
3403
 
        ui.ui_factory.warn_experimental_format_fetch(self)
3404
2981
        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
2982
        f = RepoFetcher(to_repository=self.target,
3411
2983
                               from_repository=self.source,
3412
2984
                               last_revision=revision_id,
3413
2985
                               fetch_spec=fetch_spec,
3414
 
                               find_ghosts=find_ghosts)
 
2986
                               pb=pb, find_ghosts=find_ghosts)
3415
2987
 
3416
2988
    def _walk_to_common_revisions(self, revision_ids):
3417
2989
        """Walk out from revision_ids in source to revisions target has.
3421
2993
        """
3422
2994
        target_graph = self.target.get_graph()
3423
2995
        revision_ids = frozenset(revision_ids)
 
2996
        # Fast path for the case where all the revisions are already in the
 
2997
        # target repo.
 
2998
        # (Although this does incur an extra round trip for the
 
2999
        # fairly common case where the target doesn't already have the revision
 
3000
        # we're pushing.)
 
3001
        if set(target_graph.get_parent_map(revision_ids)) == revision_ids:
 
3002
            return graph.SearchResult(revision_ids, set(), 0, set())
3424
3003
        missing_revs = set()
3425
3004
        source_graph = self.source.get_graph()
3426
3005
        # ensure we don't pay silly lookup costs.
3465
3044
                break
3466
3045
        return searcher.get_result()
3467
3046
 
 
3047
    @deprecated_method(one_two)
 
3048
    @needs_read_lock
 
3049
    def missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
3050
        """Return the revision ids that source has that target does not.
 
3051
 
 
3052
        These are returned in topological order.
 
3053
 
 
3054
        :param revision_id: only return revision ids included by this
 
3055
                            revision_id.
 
3056
        :param find_ghosts: If True find missing revisions in deep history
 
3057
            rather than just finding the surface difference.
 
3058
        """
 
3059
        return list(self.search_missing_revision_ids(
 
3060
            revision_id, find_ghosts).get_keys())
 
3061
 
3468
3062
    @needs_read_lock
3469
3063
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
3470
3064
        """Return the revision ids that source has that target does not.
3586
3180
                self.target.texts.insert_record_stream(
3587
3181
                    self.source.texts.get_record_stream(
3588
3182
                        self.source.texts.keys(), 'topological', False))
3589
 
                pb.update('Copying inventory', 0, 1)
 
3183
                pb.update('copying inventory', 0, 1)
3590
3184
                self.target.inventories.insert_record_stream(
3591
3185
                    self.source.inventories.get_record_stream(
3592
3186
                        self.source.inventories.keys(), 'topological', False))
3613
3207
        # so the first thing is to get a subset of the revisions to
3614
3208
        # satisfy revision_id in source, and then eliminate those that
3615
3209
        # we do already have.
3616
 
        # this is slow on high latency connection to self, but as this
 
3210
        # this is slow on high latency connection to self, but as as this
3617
3211
        # disk format scales terribly for push anyway due to rewriting
3618
3212
        # inventory.weave, this is considered acceptable.
3619
3213
        # - RBC 20060209
3706
3300
        return self.source.revision_ids_to_search_result(result_set)
3707
3301
 
3708
3302
 
3709
 
class InterDifferingSerializer(InterRepository):
 
3303
class InterPackRepo(InterSameDataRepository):
 
3304
    """Optimised code paths between Pack based repositories."""
 
3305
 
 
3306
    @classmethod
 
3307
    def _get_repo_format_to_test(self):
 
3308
        from bzrlib.repofmt import pack_repo
 
3309
        return pack_repo.RepositoryFormatKnitPack1()
 
3310
 
 
3311
    @staticmethod
 
3312
    def is_compatible(source, target):
 
3313
        """Be compatible with known Pack formats.
 
3314
 
 
3315
        We don't test for the stores being of specific types because that
 
3316
        could lead to confusing results, and there is no need to be
 
3317
        overly general.
 
3318
        """
 
3319
        from bzrlib.repofmt.pack_repo import RepositoryFormatPack
 
3320
        try:
 
3321
            are_packs = (isinstance(source._format, RepositoryFormatPack) and
 
3322
                isinstance(target._format, RepositoryFormatPack))
 
3323
        except AttributeError:
 
3324
            return False
 
3325
        return are_packs and InterRepository._same_model(source, target)
 
3326
 
 
3327
    @needs_write_lock
 
3328
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
3329
            fetch_spec=None):
 
3330
        """See InterRepository.fetch()."""
 
3331
        if (len(self.source._fallback_repositories) > 0 or
 
3332
            len(self.target._fallback_repositories) > 0):
 
3333
            # The pack layer is not aware of fallback repositories, so when
 
3334
            # fetching from a stacked repository or into a stacked repository
 
3335
            # we use the generic fetch logic which uses the VersionedFiles
 
3336
            # attributes on repository.
 
3337
            from bzrlib.fetch import RepoFetcher
 
3338
            fetcher = RepoFetcher(self.target, self.source, revision_id,
 
3339
                    pb, find_ghosts, fetch_spec=fetch_spec)
 
3340
        if fetch_spec is not None:
 
3341
            if len(list(fetch_spec.heads)) != 1:
 
3342
                raise AssertionError(
 
3343
                    "InterPackRepo.fetch doesn't support "
 
3344
                    "fetching multiple heads yet.")
 
3345
            revision_id = list(fetch_spec.heads)[0]
 
3346
            fetch_spec = None
 
3347
        if revision_id is None:
 
3348
            # TODO:
 
3349
            # everything to do - use pack logic
 
3350
            # to fetch from all packs to one without
 
3351
            # inventory parsing etc, IFF nothing to be copied is in the target.
 
3352
            # till then:
 
3353
            source_revision_ids = frozenset(self.source.all_revision_ids())
 
3354
            revision_ids = source_revision_ids - \
 
3355
                frozenset(self.target.get_parent_map(source_revision_ids))
 
3356
            revision_keys = [(revid,) for revid in revision_ids]
 
3357
            index = self.target._pack_collection.revision_index.combined_index
 
3358
            present_revision_ids = set(item[1][0] for item in
 
3359
                index.iter_entries(revision_keys))
 
3360
            revision_ids = set(revision_ids) - present_revision_ids
 
3361
            # implementing the TODO will involve:
 
3362
            # - detecting when all of a pack is selected
 
3363
            # - avoiding as much as possible pre-selection, so the
 
3364
            # more-core routines such as create_pack_from_packs can filter in
 
3365
            # a just-in-time fashion. (though having a HEADS list on a
 
3366
            # repository might make this a lot easier, because we could
 
3367
            # sensibly detect 'new revisions' without doing a full index scan.
 
3368
        elif _mod_revision.is_null(revision_id):
 
3369
            # nothing to do:
 
3370
            return (0, [])
 
3371
        else:
 
3372
            try:
 
3373
                revision_ids = self.search_missing_revision_ids(revision_id,
 
3374
                    find_ghosts=find_ghosts).get_keys()
 
3375
            except errors.NoSuchRevision:
 
3376
                raise errors.InstallFailed([revision_id])
 
3377
            if len(revision_ids) == 0:
 
3378
                return (0, [])
 
3379
        return self._pack(self.source, self.target, revision_ids)
 
3380
 
 
3381
    def _pack(self, source, target, revision_ids):
 
3382
        from bzrlib.repofmt.pack_repo import Packer
 
3383
        packs = source._pack_collection.all_packs()
 
3384
        pack = Packer(self.target._pack_collection, packs, '.fetch',
 
3385
            revision_ids).pack()
 
3386
        if pack is not None:
 
3387
            self.target._pack_collection._save_pack_names()
 
3388
            copied_revs = pack.get_revision_count()
 
3389
            # Trigger an autopack. This may duplicate effort as we've just done
 
3390
            # a pack creation, but for now it is simpler to think about as
 
3391
            # 'upload data, then repack if needed'.
 
3392
            self.target._pack_collection.autopack()
 
3393
            return (copied_revs, [])
 
3394
        else:
 
3395
            return (0, [])
 
3396
 
 
3397
    @needs_read_lock
 
3398
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
3399
        """See InterRepository.missing_revision_ids().
 
3400
 
 
3401
        :param find_ghosts: Find ghosts throughout the ancestry of
 
3402
            revision_id.
 
3403
        """
 
3404
        if not find_ghosts and revision_id is not None:
 
3405
            return self._walk_to_common_revisions([revision_id])
 
3406
        elif revision_id is not None:
 
3407
            # Find ghosts: search for revisions pointing from one repository to
 
3408
            # the other, and vice versa, anywhere in the history of revision_id.
 
3409
            graph = self.target.get_graph(other_repository=self.source)
 
3410
            searcher = graph._make_breadth_first_searcher([revision_id])
 
3411
            found_ids = set()
 
3412
            while True:
 
3413
                try:
 
3414
                    next_revs, ghosts = searcher.next_with_ghosts()
 
3415
                except StopIteration:
 
3416
                    break
 
3417
                if revision_id in ghosts:
 
3418
                    raise errors.NoSuchRevision(self.source, revision_id)
 
3419
                found_ids.update(next_revs)
 
3420
                found_ids.update(ghosts)
 
3421
            found_ids = frozenset(found_ids)
 
3422
            # Double query here: should be able to avoid this by changing the
 
3423
            # graph api further.
 
3424
            result_set = found_ids - frozenset(
 
3425
                self.target.get_parent_map(found_ids))
 
3426
        else:
 
3427
            source_ids = self.source.all_revision_ids()
 
3428
            # source_ids is the worst possible case we may need to pull.
 
3429
            # now we want to filter source_ids against what we actually
 
3430
            # have in target, but don't try to check for existence where we know
 
3431
            # we do not have a revision as that would be pointless.
 
3432
            target_ids = set(self.target.all_revision_ids())
 
3433
            result_set = set(source_ids).difference(target_ids)
 
3434
        return self.source.revision_ids_to_search_result(result_set)
 
3435
 
 
3436
 
 
3437
class InterDifferingSerializer(InterKnitRepo):
3710
3438
 
3711
3439
    @classmethod
3712
3440
    def _get_repo_format_to_test(self):
3715
3443
    @staticmethod
3716
3444
    def is_compatible(source, target):
3717
3445
        """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:///'):
 
3446
        if source.supports_rich_root() != target.supports_rich_root():
 
3447
            return False
 
3448
        # Ideally, we'd support fetching if the source had no tree references
 
3449
        # even if it supported them...
 
3450
        if (getattr(source, '_format.supports_tree_reference', False) and
 
3451
            not getattr(target, '_format.supports_tree_reference', False)):
3739
3452
            return False
3740
3453
        return True
3741
3454
 
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):
 
3455
    def _get_delta_for_revision(self, tree, parent_ids, basis_id, cache):
3760
3456
        """Get the best delta and base for this revision.
3761
3457
 
3762
3458
        :return: (basis_id, delta)
3763
3459
        """
 
3460
        possible_trees = [(parent_id, cache[parent_id])
 
3461
                          for parent_id in parent_ids
 
3462
                           if parent_id in cache]
 
3463
        if len(possible_trees) == 0:
 
3464
            # There either aren't any parents, or the parents aren't in the
 
3465
            # cache, so just use the last converted tree
 
3466
            possible_trees.append((basis_id, cache[basis_id]))
3764
3467
        deltas = []
3765
 
        # Generate deltas against each tree, to find the shortest.
3766
 
        texts_possibly_new_in_tree = set()
3767
3468
        for basis_id, basis_tree in possible_trees:
3768
3469
            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
3470
            deltas.append((len(delta), basis_id, delta))
3784
3471
        deltas.sort()
3785
3472
        return deltas[0][1:]
3786
3473
 
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):
 
3474
    def _fetch_batch(self, revision_ids, basis_id, cache):
3817
3475
        """Fetch across a few revisions.
3818
3476
 
3819
3477
        :param revision_ids: The revisions to copy
3820
3478
        :param basis_id: The revision_id of a tree that must be in cache, used
3821
3479
            as a basis for delta when no other base is available
3822
3480
        :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
3481
        :return: The revision_id of the last converted tree. The RevisionTree
3826
3482
            for it will be in cache
3827
3483
        """
3828
3484
        # Walk though all revisions; get inventory deltas, copy referenced
3829
3485
        # texts that delta references, insert the delta, revision and
3830
3486
        # signature.
3831
 
        root_keys_to_create = set()
3832
3487
        text_keys = set()
3833
3488
        pending_deltas = []
3834
3489
        pending_revisions = []
3835
3490
        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
3491
        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
3492
            current_revision_id = tree.get_revision_id()
3842
3493
            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
3494
            basis_id, delta = self._get_delta_for_revision(tree, parent_ids,
3850
 
                                                           possible_trees)
 
3495
                                                           basis_id, cache)
 
3496
            # Find text entries that need to be copied
 
3497
            for old_path, new_path, file_id, entry in delta:
 
3498
                if new_path is not None:
 
3499
                    if not (new_path or self.target.supports_rich_root()):
 
3500
                        # We don't copy the text for the root node unless the
 
3501
                        # target supports_rich_root.
 
3502
                        continue
 
3503
                    text_keys.add((file_id, entry.revision))
3851
3504
            revision = self.source.get_revision(current_revision_id)
3852
3505
            pending_deltas.append((basis_id, delta,
3853
3506
                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
3507
            pending_revisions.append(revision)
3889
3508
            cache[current_revision_id] = tree
3890
3509
            basis_id = current_revision_id
3891
 
        self.source._safe_to_return_from_cache = False
3892
3510
        # Copy file texts
3893
3511
        from_texts = self.source.texts
3894
3512
        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
3513
        to_texts.insert_record_stream(from_texts.get_record_stream(
3901
3514
            text_keys, self.target._format._fetch_order,
3902
3515
            not self.target._format._fetch_uses_deltas))
3903
 
        # insert inventory deltas
 
3516
        # insert deltas
3904
3517
        for delta in pending_deltas:
3905
3518
            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
3519
        # insert signatures and revisions
3936
3520
        for revision in pending_revisions:
3937
3521
            try:
3949
3533
 
3950
3534
        :param revision_ids: The list of revisions to fetch. Must be in
3951
3535
            topological order.
3952
 
        :param pb: A ProgressTask
 
3536
        :param pb: A ProgressBar
3953
3537
        :return: None
3954
3538
        """
3955
3539
        basis_id, basis_tree = self._get_basis(revision_ids[0])
3957
3541
        cache = lru_cache.LRUCache(100)
3958
3542
        cache[basis_id] = basis_tree
3959
3543
        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
3544
        for offset in range(0, len(revision_ids), batch_size):
3968
3545
            self.target.start_write_group()
3969
3546
            try:
3970
3547
                pb.update('Transferring revisions', offset,
3971
3548
                          len(revision_ids))
3972
3549
                batch = revision_ids[offset:offset+batch_size]
3973
 
                basis_id = self._fetch_batch(batch, basis_id, cache,
3974
 
                                             a_graph=a_graph)
 
3550
                basis_id = self._fetch_batch(batch, basis_id, cache)
3975
3551
            except:
3976
 
                self.source._safe_to_return_from_cache = False
3977
3552
                self.target.abort_write_group()
3978
3553
                raise
3979
3554
            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)
 
3555
                self.target.commit_write_group()
3985
3556
        pb.update('Transferring revisions', len(revision_ids),
3986
3557
                  len(revision_ids))
3987
3558
 
3991
3562
        """See InterRepository.fetch()."""
3992
3563
        if fetch_spec is not None:
3993
3564
            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
3565
        revision_ids = self.target.search_missing_revision_ids(self.source,
4007
3566
            revision_id, find_ghosts=find_ghosts).get_keys()
4008
3567
        if not revision_ids:
4009
3568
            return 0, 0
4010
3569
        revision_ids = tsort.topo_sort(
4011
3570
            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
3571
        if pb is None:
4018
3572
            my_pb = ui.ui_factory.nested_progress_bar()
4019
3573
            pb = my_pb
4056
3610
InterRepository.register_optimiser(InterSameDataRepository)
4057
3611
InterRepository.register_optimiser(InterWeaveRepo)
4058
3612
InterRepository.register_optimiser(InterKnitRepo)
 
3613
InterRepository.register_optimiser(InterPackRepo)
4059
3614
 
4060
3615
 
4061
3616
class CopyConverter(object):
4077
3632
        :param to_convert: The disk object to convert.
4078
3633
        :param pb: a progress bar to use for progress information.
4079
3634
        """
4080
 
        pb = ui.ui_factory.nested_progress_bar()
 
3635
        self.pb = pb
4081
3636
        self.count = 0
4082
3637
        self.total = 4
4083
3638
        # this is only useful with metadir layouts - separated repo content.
4084
3639
        # trigger an assertion if not such
4085
3640
        repo._format.get_format_string()
4086
3641
        self.repo_dir = repo.bzrdir
4087
 
        pb.update('Moving repository to repository.backup')
 
3642
        self.step('Moving repository to repository.backup')
4088
3643
        self.repo_dir.transport.move('repository', 'repository.backup')
4089
3644
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
4090
3645
        repo._format.check_conversion_target(self.target_format)
4091
3646
        self.source_repo = repo._format.open(self.repo_dir,
4092
3647
            _found=True,
4093
3648
            _override_transport=backup_transport)
4094
 
        pb.update('Creating new repository')
 
3649
        self.step('Creating new repository')
4095
3650
        converted = self.target_format.initialize(self.repo_dir,
4096
3651
                                                  self.source_repo.is_shared())
4097
3652
        converted.lock_write()
4098
3653
        try:
4099
 
            pb.update('Copying content')
 
3654
            self.step('Copying content into repository.')
4100
3655
            self.source_repo.copy_content_into(converted)
4101
3656
        finally:
4102
3657
            converted.unlock()
4103
 
        pb.update('Deleting old repository content')
 
3658
        self.step('Deleting old repository content.')
4104
3659
        self.repo_dir.transport.delete_tree('repository.backup')
4105
 
        ui.ui_factory.note('repository converted')
4106
 
        pb.finished()
 
3660
        self.pb.note('repository converted')
 
3661
 
 
3662
    def step(self, message):
 
3663
        """Update the pb by a step."""
 
3664
        self.count +=1
 
3665
        self.pb.update(message, self.count, self.total)
4107
3666
 
4108
3667
 
4109
3668
_unescape_map = {
4138
3697
 
4139
3698
class _VersionedFileChecker(object):
4140
3699
 
4141
 
    def __init__(self, repository, text_key_references=None, ancestors=None):
 
3700
    def __init__(self, repository, text_key_references=None):
4142
3701
        self.repository = repository
4143
3702
        self.text_index = self.repository._generate_text_key_index(
4144
 
            text_key_references=text_key_references, ancestors=ancestors)
 
3703
            text_key_references=text_key_references)
4145
3704
 
4146
3705
    def calculate_file_version_parents(self, text_key):
4147
3706
        """Calculate the correct parents for a file version according to
4165
3724
            revision_id) tuples for versions that are present in this versioned
4166
3725
            file, but not used by the corresponding inventory.
4167
3726
        """
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
3727
        wrong_parents = {}
4181
3728
        self.file_ids = set([file_id for file_id, _ in
4182
3729
            self.text_index.iterkeys()])
4183
3730
        # text keys is now grouped by file_id
 
3731
        n_weaves = len(self.file_ids)
 
3732
        files_in_revisions = {}
 
3733
        revisions_of_files = {}
4184
3734
        n_versions = len(self.text_index)
4185
3735
        progress_bar.update('loading text store', 0, n_versions)
4186
3736
        parent_map = self.repository.texts.get_parent_map(self.text_index)
4188
3738
        text_keys = self.repository.texts.keys()
4189
3739
        unused_keys = frozenset(text_keys) - set(self.text_index)
4190
3740
        for num, key in enumerate(self.text_index.iterkeys()):
4191
 
            progress_bar.update('checking text graph', num, n_versions)
 
3741
            if progress_bar is not None:
 
3742
                progress_bar.update('checking text graph', num, n_versions)
4192
3743
            correct_parents = self.calculate_file_version_parents(key)
4193
3744
            try:
4194
3745
                knit_parents = parent_map[key]
4243
3794
        try:
4244
3795
            if resume_tokens:
4245
3796
                self.target_repo.resume_write_group(resume_tokens)
4246
 
                is_resume = True
4247
3797
            else:
4248
3798
                self.target_repo.start_write_group()
4249
 
                is_resume = False
4250
3799
            try:
4251
3800
                # locked_insert_stream performs a commit|suspend.
4252
 
                return self._locked_insert_stream(stream, src_format, is_resume)
 
3801
                return self._locked_insert_stream(stream, src_format)
4253
3802
            except:
4254
3803
                self.target_repo.abort_write_group(suppress_errors=True)
4255
3804
                raise
4256
3805
        finally:
4257
3806
            self.target_repo.unlock()
4258
3807
 
4259
 
    def _locked_insert_stream(self, stream, src_format, is_resume):
 
3808
    def _locked_insert_stream(self, stream, src_format):
4260
3809
        to_serializer = self.target_repo._format._serializer
4261
3810
        src_serializer = src_format._serializer
4262
 
        new_pack = None
4263
 
        if to_serializer == src_serializer:
4264
 
            # If serializers match and the target is a pack repository, set the
4265
 
            # write cache size on the new pack.  This avoids poor performance
4266
 
            # on transports where append is unbuffered (such as
4267
 
            # RemoteTransport).  This is safe to do because nothing should read
4268
 
            # back from the target repository while a stream with matching
4269
 
            # serialization is being inserted.
4270
 
            # The exception is that a delta record from the source that should
4271
 
            # be a fulltext may need to be expanded by the target (see
4272
 
            # test_fetch_revisions_with_deltas_into_pack); but we take care to
4273
 
            # explicitly flush any buffered writes first in that rare case.
4274
 
            try:
4275
 
                new_pack = self.target_repo._pack_collection._new_pack
4276
 
            except AttributeError:
4277
 
                # Not a pack repository
4278
 
                pass
4279
 
            else:
4280
 
                new_pack.set_write_cache_size(1024*1024)
4281
3811
        for substream_type, substream in stream:
4282
 
            if 'stream' in debug.debug_flags:
4283
 
                mutter('inserting substream: %s', substream_type)
4284
3812
            if substream_type == 'texts':
4285
3813
                self.target_repo.texts.insert_record_stream(substream)
4286
3814
            elif substream_type == 'inventories':
4290
3818
                else:
4291
3819
                    self._extract_and_insert_inventories(
4292
3820
                        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
3821
            elif substream_type == 'revisions':
4301
3822
                # This may fallback to extract-and-insert more often than
4302
3823
                # required if the serializers are different only in terms of
4311
3832
                self.target_repo.signatures.insert_record_stream(substream)
4312
3833
            else:
4313
3834
                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
3835
        try:
 
3836
            missing_keys = set()
4323
3837
            for prefix, versioned_file in (
4324
3838
                ('texts', self.target_repo.texts),
4325
3839
                ('inventories', self.target_repo.inventories),
4326
3840
                ('revisions', self.target_repo.revisions),
4327
3841
                ('signatures', self.target_repo.signatures),
4328
 
                ('chk_bytes', self.target_repo.chk_bytes),
4329
3842
                ):
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
3843
                missing_keys.update((prefix,) + key for key in
4340
3844
                    versioned_file.get_missing_compression_parent_keys())
4341
3845
        except NotImplementedError:
4350
3854
                # missing keys can handle suspending a write group).
4351
3855
                write_group_tokens = self.target_repo.suspend_write_group()
4352
3856
                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)
 
3857
        self.target_repo.commit_write_group()
4357
3858
        return [], set()
4358
3859
 
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):
 
3860
    def _extract_and_insert_inventories(self, substream, serializer):
4380
3861
        """Generate a new inventory versionedfile in target, converting data.
4381
3862
 
4382
3863
        The inventory is retrieved from the source, (deserializing it), and
4383
3864
        stored in the target (reserializing it in a different format).
4384
3865
        """
4385
 
        target_rich_root = self.target_repo._format.rich_root_data
4386
 
        target_tree_refs = self.target_repo._format.supports_tree_reference
4387
3866
        for record in substream:
4388
 
            # It's not a delta, so it must be a fulltext in the source
4389
 
            # serializer's format.
4390
3867
            bytes = record.get_bytes_as('fulltext')
4391
3868
            revision_id = record.key[0]
4392
3869
            inv = serializer.read_inventory_from_string(bytes, revision_id)
4393
3870
            parents = [key[0] for key in record.parents]
4394
3871
            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
3872
 
4399
3873
    def _extract_and_insert_revisions(self, substream, serializer):
4400
3874
        for record in substream:
4449
3923
        return [('signatures', signatures), ('revisions', revisions)]
4450
3924
 
4451
3925
    def _generate_root_texts(self, revs):
4452
 
        """This will be called by get_stream between fetching weave texts and
 
3926
        """This will be called by __fetch between fetching weave texts and
4453
3927
        fetching the inventory weave.
 
3928
 
 
3929
        Subclasses should override this if they need to generate root texts
 
3930
        after fetching weave texts.
4454
3931
        """
4455
3932
        if self._rich_root_upgrade():
4456
 
            return _mod_fetch.Inter1and2Helper(
 
3933
            import bzrlib.fetch
 
3934
            return bzrlib.fetch.Inter1and2Helper(
4457
3935
                self.from_repository).generate_root_texts(revs)
4458
3936
        else:
4459
3937
            return []
4462
3940
        phase = 'file'
4463
3941
        revs = search.get_keys()
4464
3942
        graph = self.from_repository.get_graph()
4465
 
        revs = tsort.topo_sort(graph.get_parent_map(revs))
 
3943
        revs = list(graph.iter_topo_order(revs))
4466
3944
        data_to_fetch = self.from_repository.item_keys_introduced_by(revs)
4467
3945
        text_keys = []
4468
3946
        for knit_kind, file_id, revisions in data_to_fetch:
4487
3965
                # will be valid.
4488
3966
                for _ in self._generate_root_texts(revs):
4489
3967
                    yield _
 
3968
                # NB: This currently reopens the inventory weave in source;
 
3969
                # using a single stream interface instead would avoid this.
 
3970
                from_weave = self.from_repository.inventories
4490
3971
                # we fetch only the referenced inventories because we do not
4491
3972
                # know for unselected inventories whether all their required
4492
3973
                # texts are present in the other repository - it could be
4493
3974
                # corrupt.
4494
 
                for info in self._get_inventory_stream(revs):
4495
 
                    yield info
 
3975
                yield ('inventories', from_weave.get_record_stream(
 
3976
                    [(rev_id,) for rev_id in revs],
 
3977
                    self.inventory_fetch_order(),
 
3978
                    not self.delta_on_metadata()))
4496
3979
            elif knit_kind == "signatures":
4497
3980
                # Nothing to do here; this will be taken care of when
4498
3981
                # _fetch_revision_texts happens.
4511
3994
        keys['texts'] = set()
4512
3995
        keys['revisions'] = set()
4513
3996
        keys['inventories'] = set()
4514
 
        keys['chk_bytes'] = set()
4515
3997
        keys['signatures'] = set()
4516
3998
        for key in missing_keys:
4517
3999
            keys[key[0]].add(key[1:])
4524
4006
                    keys['revisions'],))
4525
4007
        for substream_kind, keys in keys.iteritems():
4526
4008
            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
4009
            # Ask for full texts always so that we don't need more round trips
4547
4010
            # 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))
 
4011
            stream = vf.get_record_stream(keys,
 
4012
                self.to_format._fetch_order, True)
4554
4013
            yield substream_kind, stream
4555
4014
 
4556
4015
    def inventory_fetch_order(self):
4563
4022
        return (not self.from_repository._format.rich_root_data and
4564
4023
            self.to_format.rich_root_data)
4565
4024
 
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