594
552
return new_pack.data_inserted() and self._data_changed
597
class GCCHKCanonicalizingPacker(GCCHKPacker):
598
"""A packer that ensures inventories have canonical-form CHK maps.
600
Ideally this would be part of reconcile, but it's very slow and rarely
601
needed. (It repairs repositories affected by
602
https://bugs.launchpad.net/bzr/+bug/522637).
605
def __init__(self, *args, **kwargs):
606
super(GCCHKCanonicalizingPacker, self).__init__(*args, **kwargs)
607
self._data_changed = False
609
def _exhaust_stream(self, source_vf, keys, message, vf_to_stream, pb_offset):
610
"""Create and exhaust a stream, but don't insert it.
612
This is useful to get the side-effects of generating a stream.
614
self.pb.update('scanning %s' % (message,), pb_offset)
615
child_pb = ui.ui_factory.nested_progress_bar()
617
list(vf_to_stream(source_vf, keys, message, child_pb))
621
def _copy_inventory_texts(self):
622
source_vf, target_vf = self._build_vfs('inventory', True, True)
623
source_chk_vf, target_chk_vf = self._get_chk_vfs_for_copy()
624
inventory_keys = source_vf.keys()
625
# First, copy the existing CHKs on the assumption that most of them
626
# will be correct. This will save us from having to reinsert (and
627
# recompress) these records later at the cost of perhaps preserving a
629
# (Iterate but don't insert _get_filtered_inv_stream to populate the
630
# variables needed by GCCHKPacker._copy_chk_texts.)
631
self._exhaust_stream(source_vf, inventory_keys, 'inventories',
632
self._get_filtered_inv_stream, 2)
633
GCCHKPacker._copy_chk_texts(self)
634
# Now copy and fix the inventories, and any regenerated CHKs.
635
def chk_canonicalizing_inv_stream(source_vf, keys, message, pb=None):
636
return self._get_filtered_canonicalizing_inv_stream(
637
source_vf, keys, message, pb, source_chk_vf, target_chk_vf)
638
self._copy_stream(source_vf, target_vf, inventory_keys,
639
'inventories', chk_canonicalizing_inv_stream, 4)
641
def _copy_chk_texts(self):
642
# No-op; in this class this happens during _copy_inventory_texts.
645
def _get_filtered_canonicalizing_inv_stream(self, source_vf, keys, message,
646
pb=None, source_chk_vf=None, target_chk_vf=None):
647
"""Filter the texts of inventories, regenerating CHKs to make sure they
650
total_keys = len(keys)
651
target_chk_vf = versionedfile.NoDupeAddLinesDecorator(target_chk_vf)
652
def _filtered_inv_stream():
653
stream = source_vf.get_record_stream(keys, 'groupcompress', True)
654
search_key_name = None
655
for idx, record in enumerate(stream):
656
# Inventories should always be with revisions; assume success.
657
bytes = record.get_bytes_as('fulltext')
658
chk_inv = inventory.CHKInventory.deserialise(
659
source_chk_vf, bytes, record.key)
661
pb.update('inv', idx, total_keys)
662
chk_inv.id_to_entry._ensure_root()
663
if search_key_name is None:
664
# Find the name corresponding to the search_key_func
665
search_key_reg = chk_map.search_key_registry
666
for search_key_name, func in search_key_reg.iteritems():
667
if func == chk_inv.id_to_entry._search_key_func:
669
canonical_inv = inventory.CHKInventory.from_inventory(
670
target_chk_vf, chk_inv,
671
maximum_size=chk_inv.id_to_entry._root_node._maximum_size,
672
search_key_name=search_key_name)
673
if chk_inv.id_to_entry.key() != canonical_inv.id_to_entry.key():
675
'Non-canonical CHK map for id_to_entry of inv: %s '
676
'(root is %s, should be %s)' % (chk_inv.revision_id,
677
chk_inv.id_to_entry.key()[0],
678
canonical_inv.id_to_entry.key()[0]))
679
self._data_changed = True
680
p_id_map = chk_inv.parent_id_basename_to_file_id
681
p_id_map._ensure_root()
682
canon_p_id_map = canonical_inv.parent_id_basename_to_file_id
683
if p_id_map.key() != canon_p_id_map.key():
685
'Non-canonical CHK map for parent_id_to_basename of '
686
'inv: %s (root is %s, should be %s)'
687
% (chk_inv.revision_id, p_id_map.key()[0],
688
canon_p_id_map.key()[0]))
689
self._data_changed = True
690
yield versionedfile.ChunkedContentFactory(record.key,
691
record.parents, record.sha1,
692
canonical_inv.to_lines())
693
# We have finished processing all of the inventory records, we
694
# don't need these sets anymore
695
return _filtered_inv_stream()
697
def _use_pack(self, new_pack):
698
"""Override _use_pack to check for reconcile having changed content."""
699
return new_pack.data_inserted() and self._data_changed
702
555
class GCRepositoryPackCollection(RepositoryPackCollection):
704
557
pack_factory = GCPack
705
558
resumed_pack_factory = ResumedGCPack
706
normal_packer_class = GCCHKPacker
707
optimising_packer_class = GCCHKPacker
709
def _check_new_inventories(self):
710
"""Detect missing inventories or chk root entries for the new revisions
713
:returns: list of strs, summarising any problems found. If the list is
714
empty no problems were found.
560
def _already_packed(self):
561
"""Is the collection already packed?"""
562
# Always repack GC repositories for now
565
def _execute_pack_operations(self, pack_operations,
566
_packer_class=GCCHKPacker,
568
"""Execute a series of pack operations.
570
:param pack_operations: A list of [revision_count, packs_to_combine].
571
:param _packer_class: The class of packer to use (default: Packer).
716
# Ensure that all revisions added in this write group have:
717
# - corresponding inventories,
718
# - chk root entries for those inventories,
719
# - and any present parent inventories have their chk root
721
# And all this should be independent of any fallback repository.
723
key_deps = self.repo.revisions._index._key_dependencies
724
new_revisions_keys = key_deps.get_new_keys()
725
no_fallback_inv_index = self.repo.inventories._index
726
no_fallback_chk_bytes_index = self.repo.chk_bytes._index
727
no_fallback_texts_index = self.repo.texts._index
728
inv_parent_map = no_fallback_inv_index.get_parent_map(
730
# Are any inventories for corresponding to the new revisions missing?
731
corresponding_invs = set(inv_parent_map)
732
missing_corresponding = set(new_revisions_keys)
733
missing_corresponding.difference_update(corresponding_invs)
734
if missing_corresponding:
735
problems.append("inventories missing for revisions %s" %
736
(sorted(missing_corresponding),))
738
# Are any chk root entries missing for any inventories? This includes
739
# any present parent inventories, which may be used when calculating
740
# deltas for streaming.
741
all_inv_keys = set(corresponding_invs)
742
for parent_inv_keys in inv_parent_map.itervalues():
743
all_inv_keys.update(parent_inv_keys)
744
# Filter out ghost parents.
745
all_inv_keys.intersection_update(
746
no_fallback_inv_index.get_parent_map(all_inv_keys))
747
parent_invs_only_keys = all_inv_keys.symmetric_difference(
750
inv_ids = [key[-1] for key in all_inv_keys]
751
parent_invs_only_ids = [key[-1] for key in parent_invs_only_keys]
752
root_key_info = _build_interesting_key_sets(
753
self.repo, inv_ids, parent_invs_only_ids)
754
expected_chk_roots = root_key_info.all_keys()
755
present_chk_roots = no_fallback_chk_bytes_index.get_parent_map(
757
missing_chk_roots = expected_chk_roots.difference(present_chk_roots)
758
if missing_chk_roots:
759
problems.append("missing referenced chk root keys: %s"
760
% (sorted(missing_chk_roots),))
761
# Don't bother checking any further.
763
# Find all interesting chk_bytes records, and make sure they are
764
# present, as well as the text keys they reference.
765
chk_bytes_no_fallbacks = self.repo.chk_bytes.without_fallbacks()
766
chk_bytes_no_fallbacks._search_key_func = \
767
self.repo.chk_bytes._search_key_func
768
chk_diff = chk_map.iter_interesting_nodes(
769
chk_bytes_no_fallbacks, root_key_info.interesting_root_keys,
770
root_key_info.uninteresting_root_keys)
773
for record in _filter_text_keys(chk_diff, text_keys,
774
chk_map._bytes_to_text_key):
776
except errors.NoSuchRevision, e:
777
# XXX: It would be nice if we could give a more precise error here.
778
problems.append("missing chk node(s) for id_to_entry maps")
779
chk_diff = chk_map.iter_interesting_nodes(
780
chk_bytes_no_fallbacks, root_key_info.interesting_pid_root_keys,
781
root_key_info.uninteresting_pid_root_keys)
783
for interesting_rec, interesting_map in chk_diff:
785
except errors.NoSuchRevision, e:
787
"missing chk node(s) for parent_id_basename_to_file_id maps")
788
present_text_keys = no_fallback_texts_index.get_parent_map(text_keys)
789
missing_text_keys = text_keys.difference(present_text_keys)
790
if missing_text_keys:
791
problems.append("missing text keys: %r"
792
% (sorted(missing_text_keys),))
796
class CHKInventoryRepository(PackRepository):
797
"""subclass of PackRepository that uses CHK based inventories."""
574
# XXX: Copied across from RepositoryPackCollection simply because we
575
# want to override the _packer_class ... :(
576
for revision_count, packs in pack_operations:
577
# we may have no-ops from the setup logic
580
packer = GCCHKPacker(self, packs, '.autopack',
581
reload_func=reload_func)
584
except errors.RetryWithNewPacks:
585
# An exception is propagating out of this context, make sure
586
# this packer has cleaned up. Packer() doesn't set its new_pack
587
# state into the RepositoryPackCollection object, so we only
588
# have access to it directly here.
589
if packer.new_pack is not None:
590
packer.new_pack.abort()
593
self._remove_pack_from_memory(pack)
594
# record the newly available packs and stop advertising the old
596
self._save_pack_names(clear_obsolete_packs=True)
597
# Move the old packs out of the way now they are no longer referenced.
598
for revision_count, packs in pack_operations:
599
self._obsolete_packs(packs)
602
class CHKInventoryRepository(KnitPackRepository):
603
"""subclass of KnitPackRepository that uses CHK based inventories."""
799
605
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
801
607
"""Overridden to change pack collection class."""
802
super(CHKInventoryRepository, self).__init__(_format, a_bzrdir,
803
control_files, _commit_builder_class, _serializer)
608
KnitPackRepository.__init__(self, _format, a_bzrdir, control_files,
609
_commit_builder_class, _serializer)
610
# and now replace everything it did :)
804
611
index_transport = self._transport.clone('indices')
805
612
self._pack_collection = GCRepositoryPackCollection(self,
806
613
self._transport, index_transport,
813
620
self.inventories = GroupCompressVersionedFiles(
814
621
_GCGraphIndex(self._pack_collection.inventory_index.combined_index,
815
622
add_callback=self._pack_collection.inventory_index.add_callback,
816
parents=True, is_locked=self.is_locked,
817
inconsistency_fatal=False),
623
parents=True, is_locked=self.is_locked),
818
624
access=self._pack_collection.inventory_index.data_access)
819
625
self.revisions = GroupCompressVersionedFiles(
820
626
_GCGraphIndex(self._pack_collection.revision_index.combined_index,
821
627
add_callback=self._pack_collection.revision_index.add_callback,
822
628
parents=True, is_locked=self.is_locked,
823
track_external_parent_refs=True, track_new_keys=True),
629
track_external_parent_refs=True),
824
630
access=self._pack_collection.revision_index.data_access,
826
632
self.signatures = GroupCompressVersionedFiles(
827
633
_GCGraphIndex(self._pack_collection.signature_index.combined_index,
828
634
add_callback=self._pack_collection.signature_index.add_callback,
829
parents=False, is_locked=self.is_locked,
830
inconsistency_fatal=False),
635
parents=False, is_locked=self.is_locked),
831
636
access=self._pack_collection.signature_index.data_access,
833
638
self.texts = GroupCompressVersionedFiles(
834
639
_GCGraphIndex(self._pack_collection.text_index.combined_index,
835
640
add_callback=self._pack_collection.text_index.add_callback,
836
parents=True, is_locked=self.is_locked,
837
inconsistency_fatal=False),
641
parents=True, is_locked=self.is_locked),
838
642
access=self._pack_collection.text_index.data_access)
839
643
# No parents, individual CHK pages don't have specific ancestry
840
644
self.chk_bytes = GroupCompressVersionedFiles(
841
645
_GCGraphIndex(self._pack_collection.chk_index.combined_index,
842
646
add_callback=self._pack_collection.chk_index.add_callback,
843
parents=False, is_locked=self.is_locked,
844
inconsistency_fatal=False),
647
parents=False, is_locked=self.is_locked),
845
648
access=self._pack_collection.chk_index.data_access)
846
search_key_name = self._format._serializer.search_key_name
847
search_key_func = chk_map.search_key_registry.get(search_key_name)
848
self.chk_bytes._search_key_func = search_key_func
849
649
# True when the repository object is 'write locked' (as opposed to the
850
650
# physical lock only taken out around changes to the pack-names list.)
851
651
# Another way to represent this would be a decorator around the control
937
699
repository format specific) of the serialized inventory, and the
938
700
resulting inventory.
702
if basis_revision_id == _mod_revision.NULL_REVISION:
703
return KnitPackRepository.add_inventory_by_delta(self,
704
basis_revision_id, delta, new_revision_id, parents)
940
705
if not self.is_in_write_group():
941
706
raise AssertionError("%r not in write group" % (self,))
942
707
_mod_revision.check_not_reserved_id(new_revision_id)
944
if basis_inv is None:
945
if basis_revision_id == _mod_revision.NULL_REVISION:
946
new_inv = self._create_inv_from_null(delta, new_revision_id)
947
if new_inv.root_id is None:
948
raise errors.RootMissing()
949
inv_lines = new_inv.to_lines()
950
return self._inventory_add_lines(new_revision_id, parents,
951
inv_lines, check_content=False), new_inv
953
basis_tree = self.revision_tree(basis_revision_id)
954
basis_tree.lock_read()
708
basis_tree = self.revision_tree(basis_revision_id)
709
basis_tree.lock_read()
711
if basis_inv is None:
955
712
basis_inv = basis_tree.inventory
957
713
result = basis_inv.create_by_apply_delta(delta, new_revision_id,
958
714
propagate_caches=propagate_caches)
959
715
inv_lines = result.to_lines()
960
716
return self._inventory_add_lines(new_revision_id, parents,
961
717
inv_lines, check_content=False), result
963
if basis_tree is not None:
966
def _deserialise_inventory(self, revision_id, bytes):
967
return inventory.CHKInventory.deserialise(self.chk_bytes, bytes,
970
def _iter_inventories(self, revision_ids, ordering):
721
def _iter_inventories(self, revision_ids):
971
722
"""Iterate over many inventory objects."""
973
ordering = 'unordered'
974
723
keys = [(revision_id,) for revision_id in revision_ids]
975
stream = self.inventories.get_record_stream(keys, ordering, True)
724
stream = self.inventories.get_record_stream(keys, 'unordered', True)
977
726
for record in stream:
978
727
if record.storage_kind != 'absent':
1013
767
file_id_revisions = {}
1014
768
pb = ui.ui_factory.nested_progress_bar()
1016
revision_keys = [(r,) for r in revision_ids]
1017
parent_keys = self._find_parent_keys_of_revisions(revision_keys)
1018
# TODO: instead of using _find_present_inventory_keys, change the
1019
# code paths to allow missing inventories to be tolerated.
1020
# However, we only want to tolerate missing parent
1021
# inventories, not missing inventories for revision_ids
1022
present_parent_inv_keys = self._find_present_inventory_keys(
1024
present_parent_inv_ids = set(
1025
[k[-1] for k in present_parent_inv_keys])
1026
inventories_to_read = set(revision_ids)
1027
inventories_to_read.update(present_parent_inv_ids)
1028
root_key_info = _build_interesting_key_sets(
1029
self, inventories_to_read, present_parent_inv_ids)
1030
interesting_root_keys = root_key_info.interesting_root_keys
1031
uninteresting_root_keys = root_key_info.uninteresting_root_keys
770
parent_ids = self._find_parent_ids_of_revisions(revision_ids)
771
present_parent_inv_ids = self._find_present_inventory_ids(parent_ids)
772
uninteresting_root_keys = set()
773
interesting_root_keys = set()
774
inventories_to_read = set(present_parent_inv_ids)
775
inventories_to_read.update(revision_ids)
776
for inv in self.iter_inventories(inventories_to_read):
777
entry_chk_root_key = inv.id_to_entry.key()
778
if inv.revision_id in present_parent_inv_ids:
779
uninteresting_root_keys.add(entry_chk_root_key)
781
interesting_root_keys.add(entry_chk_root_key)
1032
783
chk_bytes = self.chk_bytes
1033
784
for record, items in chk_map.iter_interesting_nodes(chk_bytes,
1034
785
interesting_root_keys, uninteresting_root_keys,
1036
787
for name, bytes in items:
1037
788
(name_utf8, file_id, revision_id) = bytes_to_info(bytes)
1038
# TODO: consider interning file_id, revision_id here, or
1039
# pushing that intern() into bytes_to_info()
1040
# TODO: rich_root should always be True here, for all
1041
# repositories that support chk_bytes
1042
789
if not rich_root and name_utf8 == '':
1085
def reconcile_canonicalize_chks(self):
1086
"""Reconcile this repository to make sure all CHKs are in canonical
1089
from bzrlib.reconcile import PackReconciler
1090
reconciler = PackReconciler(self, thorough=True, canonicalize_chks=True)
1091
reconciler.reconcile()
1094
831
def _reconcile_pack(self, collection, packs, extension, revs, pb):
1095
832
packer = GCCHKReconcilePacker(collection, packs, extension)
1096
833
return packer.pack(pb)
1098
def _canonicalize_chks_pack(self, collection, packs, extension, revs, pb):
1099
packer = GCCHKCanonicalizingPacker(collection, packs, extension, revs)
1100
return packer.pack(pb)
1102
835
def _get_source(self, to_format):
1103
836
"""Return a source for streaming from this repository."""
1104
if self._format._serializer == to_format._serializer:
837
if isinstance(to_format, remote.RemoteRepositoryFormat):
838
# Can't just check attributes on to_format with the current code,
840
to_format._ensure_real()
841
to_format = to_format._custom_format
842
if to_format.__class__ is self._format.__class__:
1105
843
# We must be exactly the same format, otherwise stuff like the chk
1106
# page layout might be different.
1107
# Actually, this test is just slightly looser than exact so that
1108
# CHK2 <-> 2a transfers will work.
844
# page layout might be different
1109
845
return GroupCHKStreamSource(self, to_format)
1110
846
return super(CHKInventoryRepository, self)._get_source(to_format)
1112
def _find_inconsistent_revision_parents(self, revisions_iterator=None):
1113
"""Find revisions with different parent lists in the revision object
1114
and in the index graph.
1116
:param revisions_iterator: None, or an iterator of (revid,
1117
Revision-or-None). This iterator controls the revisions checked.
1118
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
1119
parents-in-revision).
1121
if not self.is_locked():
1122
raise AssertionError()
1124
if revisions_iterator is None:
1125
revisions_iterator = self._iter_revisions(None)
1126
for revid, revision in revisions_iterator:
1127
if revision is None:
1129
parent_map = vf.get_parent_map([(revid,)])
1130
parents_according_to_index = tuple(parent[-1] for parent in
1131
parent_map[(revid,)])
1132
parents_according_to_revision = tuple(revision.parent_ids)
1133
if parents_according_to_index != parents_according_to_revision:
1134
yield (revid, parents_according_to_index,
1135
parents_according_to_revision)
1137
def _check_for_inconsistent_revision_parents(self):
1138
inconsistencies = list(self._find_inconsistent_revision_parents())
1140
raise errors.BzrCheckError(
1141
"Revision index has inconsistent parents.")
1144
class GroupCHKStreamSource(StreamSource):
849
class GroupCHKStreamSource(repository.StreamSource):
1145
850
"""Used when both the source and target repo are GroupCHK repos."""
1147
852
def __init__(self, from_repository, to_format):
1237
951
def _get_text_stream(self):
1238
952
# Note: We know we don't have to handle adding root keys, because both
1239
# the source and target are the identical network name.
1240
text_stream = self.from_repository.texts.get_record_stream(
1241
self._text_keys, self._text_fetch_order, False)
1242
return ('texts', text_stream)
953
# the source and target are GCCHK, and those always support rich-roots
954
# We may want to request as 'unordered', in case the source has done a
956
return ('texts', self.from_repository.texts.get_record_stream(
957
self._text_keys, 'groupcompress', False))
1244
959
def get_stream(self, search):
1245
def wrap_and_count(pb, rc, stream):
1246
"""Yield records from stream while showing progress."""
1248
for record in stream:
1249
if count == rc.STEP:
1251
pb.update('Estimate', rc.current, rc.max)
1256
960
revision_ids = search.get_keys()
1257
pb = ui.ui_factory.nested_progress_bar()
1258
rc = self._record_counter
1259
self._record_counter.setup(len(revision_ids))
1260
961
for stream_info in self._fetch_revision_texts(revision_ids):
1261
yield (stream_info[0],
1262
wrap_and_count(pb, rc, stream_info[1]))
1263
963
self._revision_keys = [(rev_id,) for rev_id in revision_ids]
964
yield self._get_inventory_stream(self._revision_keys)
1264
965
# TODO: The keys to exclude might be part of the search recipe
1265
966
# For now, exclude all parents that are at the edge of ancestry, for
1266
967
# which we have inventories
1267
968
from_repo = self.from_repository
1268
parent_keys = from_repo._find_parent_keys_of_revisions(
1269
self._revision_keys)
1270
self.from_repository.revisions.clear_cache()
1271
self.from_repository.signatures.clear_cache()
1272
# Clear the repo's get_parent_map cache too.
1273
self.from_repository._unstacked_provider.disable_cache()
1274
self.from_repository._unstacked_provider.enable_cache()
1275
s = self._get_inventory_stream(self._revision_keys)
1276
yield (s[0], wrap_and_count(pb, rc, s[1]))
1277
self.from_repository.inventories.clear_cache()
1278
for stream_info in self._get_filtered_chk_streams(parent_keys):
1279
yield (stream_info[0], wrap_and_count(pb, rc, stream_info[1]))
1280
self.from_repository.chk_bytes.clear_cache()
1281
s = self._get_text_stream()
1282
yield (s[0], wrap_and_count(pb, rc, s[1]))
1283
self.from_repository.texts.clear_cache()
1284
pb.update('Done', rc.max, rc.max)
969
parent_ids = from_repo._find_parent_ids_of_revisions(revision_ids)
970
for stream_info in self._get_filtered_chk_streams(parent_ids):
972
yield self._get_text_stream()
1287
974
def get_stream_for_missing_keys(self, missing_keys):
1288
975
# missing keys can only occur when we are byte copying and not
1297
984
missing_inventory_keys.add(key[1:])
1298
985
if self._chk_id_roots or self._chk_p_id_roots:
1299
986
raise AssertionError('Cannot call get_stream_for_missing_keys'
1300
' until all of get_stream() has been consumed.')
987
' untill all of get_stream() has been consumed.')
1301
988
# Yield the inventory stream, so we can find the chk stream
1302
989
# Some of the missing_keys will be missing because they are ghosts.
1303
990
# As such, we can ignore them. The Sink is required to verify there are
1304
991
# no unavailable texts when the ghost inventories are not filled in.
1305
992
yield self._get_inventory_stream(missing_inventory_keys,
1306
993
allow_absent=True)
1307
# We use the empty set for excluded_revision_keys, to make it clear
1308
# that we want to transmit all referenced chk pages.
994
# We use the empty set for excluded_revision_ids, to make it clear that
995
# we want to transmit all referenced chk pages.
1309
996
for stream_info in self._get_filtered_chk_streams(set()):
1310
997
yield stream_info
1313
class _InterestingKeyInfo(object):
1315
self.interesting_root_keys = set()
1316
self.interesting_pid_root_keys = set()
1317
self.uninteresting_root_keys = set()
1318
self.uninteresting_pid_root_keys = set()
1320
def all_interesting(self):
1321
return self.interesting_root_keys.union(self.interesting_pid_root_keys)
1323
def all_uninteresting(self):
1324
return self.uninteresting_root_keys.union(
1325
self.uninteresting_pid_root_keys)
1328
return self.all_interesting().union(self.all_uninteresting())
1331
def _build_interesting_key_sets(repo, inventory_ids, parent_only_inv_ids):
1332
result = _InterestingKeyInfo()
1333
for inv in repo.iter_inventories(inventory_ids, 'unordered'):
1334
root_key = inv.id_to_entry.key()
1335
pid_root_key = inv.parent_id_basename_to_file_id.key()
1336
if inv.revision_id in parent_only_inv_ids:
1337
result.uninteresting_root_keys.add(root_key)
1338
result.uninteresting_pid_root_keys.add(pid_root_key)
1340
result.interesting_root_keys.add(root_key)
1341
result.interesting_pid_root_keys.add(pid_root_key)
1345
def _filter_text_keys(interesting_nodes_iterable, text_keys, bytes_to_text_key):
1346
"""Iterate the result of iter_interesting_nodes, yielding the records
1347
and adding to text_keys.
1349
text_keys_update = text_keys.update
1350
for record, items in interesting_nodes_iterable:
1351
text_keys_update([bytes_to_text_key(b) for n,b in items])
1355
class RepositoryFormat2a(RepositoryFormatPack):
1356
"""A CHK repository that uses the bencode revision serializer."""
1000
class RepositoryFormatCHK1(RepositoryFormatPack):
1001
"""A hashed CHK+group compress pack repository."""
1358
1003
repository_class = CHKInventoryRepository
1359
1004
supports_external_lookups = True
1360
1005
supports_chks = True
1006
# For right now, setting this to True gives us InterModel1And2 rather
1007
# than InterDifferingSerializer
1361
1008
_commit_builder_class = PackRootCommitBuilder
1362
1009
rich_root_data = True
1363
_serializer = chk_serializer.chk_bencode_serializer
1010
_serializer = chk_serializer.chk_serializer_255_bigpage
1364
1011
_commit_inv_deltas = True
1365
1012
# What index classes to use
1366
1013
index_builder_class = BTreeBuilder
added
removed
bzrlib/repofmt/groupcompress_repo.py
