581
540
class GCRepositoryPackCollection(RepositoryPackCollection):
583
542
pack_factory = GCPack
584
resumed_pack_factory = ResumedGCPack
586
def _check_new_inventories(self):
587
"""Detect missing inventories or chk root entries for the new revisions
590
:returns: list of strs, summarising any problems found. If the list is
591
empty no problems were found.
593
# Ensure that all revisions added in this write group have:
594
# - corresponding inventories,
595
# - chk root entries for those inventories,
596
# - and any present parent inventories have their chk root
598
# And all this should be independent of any fallback repository.
600
key_deps = self.repo.revisions._index._key_dependencies
601
new_revisions_keys = key_deps.get_new_keys()
602
no_fallback_inv_index = self.repo.inventories._index
603
no_fallback_chk_bytes_index = self.repo.chk_bytes._index
604
no_fallback_texts_index = self.repo.texts._index
605
inv_parent_map = no_fallback_inv_index.get_parent_map(
607
# Are any inventories for corresponding to the new revisions missing?
608
corresponding_invs = set(inv_parent_map)
609
missing_corresponding = set(new_revisions_keys)
610
missing_corresponding.difference_update(corresponding_invs)
611
if missing_corresponding:
612
problems.append("inventories missing for revisions %s" %
613
(sorted(missing_corresponding),))
615
# Are any chk root entries missing for any inventories? This includes
616
# any present parent inventories, which may be used when calculating
617
# deltas for streaming.
618
all_inv_keys = set(corresponding_invs)
619
for parent_inv_keys in inv_parent_map.itervalues():
620
all_inv_keys.update(parent_inv_keys)
621
# Filter out ghost parents.
622
all_inv_keys.intersection_update(
623
no_fallback_inv_index.get_parent_map(all_inv_keys))
624
parent_invs_only_keys = all_inv_keys.symmetric_difference(
627
inv_ids = [key[-1] for key in all_inv_keys]
628
parent_invs_only_ids = [key[-1] for key in parent_invs_only_keys]
629
root_key_info = _build_interesting_key_sets(
630
self.repo, inv_ids, parent_invs_only_ids)
631
expected_chk_roots = root_key_info.all_keys()
632
present_chk_roots = no_fallback_chk_bytes_index.get_parent_map(
634
missing_chk_roots = expected_chk_roots.difference(present_chk_roots)
635
if missing_chk_roots:
636
problems.append("missing referenced chk root keys: %s"
637
% (sorted(missing_chk_roots),))
638
# Don't bother checking any further.
640
# Find all interesting chk_bytes records, and make sure they are
641
# present, as well as the text keys they reference.
642
chk_bytes_no_fallbacks = self.repo.chk_bytes.without_fallbacks()
643
chk_bytes_no_fallbacks._search_key_func = \
644
self.repo.chk_bytes._search_key_func
645
chk_diff = chk_map.iter_interesting_nodes(
646
chk_bytes_no_fallbacks, root_key_info.interesting_root_keys,
647
root_key_info.uninteresting_root_keys)
650
for record in _filter_text_keys(chk_diff, text_keys,
651
chk_map._bytes_to_text_key):
653
except errors.NoSuchRevision, e:
654
# XXX: It would be nice if we could give a more precise error here.
655
problems.append("missing chk node(s) for id_to_entry maps")
656
chk_diff = chk_map.iter_interesting_nodes(
657
chk_bytes_no_fallbacks, root_key_info.interesting_pid_root_keys,
658
root_key_info.uninteresting_pid_root_keys)
660
for interesting_rec, interesting_map in chk_diff:
662
except errors.NoSuchRevision, e:
664
"missing chk node(s) for parent_id_basename_to_file_id maps")
665
present_text_keys = no_fallback_texts_index.get_parent_map(text_keys)
666
missing_text_keys = text_keys.difference(present_text_keys)
667
if missing_text_keys:
668
problems.append("missing text keys: %r"
669
% (sorted(missing_text_keys),))
544
def _already_packed(self):
545
"""Is the collection already packed?"""
546
# Always repack GC repositories for now
672
549
def _execute_pack_operations(self, pack_operations,
673
550
_packer_class=GCCHKPacker,
731
604
self.inventories = GroupCompressVersionedFiles(
732
605
_GCGraphIndex(self._pack_collection.inventory_index.combined_index,
733
606
add_callback=self._pack_collection.inventory_index.add_callback,
734
parents=True, is_locked=self.is_locked,
735
inconsistency_fatal=False),
607
parents=True, is_locked=self.is_locked),
736
608
access=self._pack_collection.inventory_index.data_access)
737
609
self.revisions = GroupCompressVersionedFiles(
738
610
_GCGraphIndex(self._pack_collection.revision_index.combined_index,
739
611
add_callback=self._pack_collection.revision_index.add_callback,
740
parents=True, is_locked=self.is_locked,
741
track_external_parent_refs=True, track_new_keys=True),
612
parents=True, is_locked=self.is_locked),
742
613
access=self._pack_collection.revision_index.data_access,
744
615
self.signatures = GroupCompressVersionedFiles(
745
616
_GCGraphIndex(self._pack_collection.signature_index.combined_index,
746
617
add_callback=self._pack_collection.signature_index.add_callback,
747
parents=False, is_locked=self.is_locked,
748
inconsistency_fatal=False),
618
parents=False, is_locked=self.is_locked),
749
619
access=self._pack_collection.signature_index.data_access,
751
621
self.texts = GroupCompressVersionedFiles(
752
622
_GCGraphIndex(self._pack_collection.text_index.combined_index,
753
623
add_callback=self._pack_collection.text_index.add_callback,
754
parents=True, is_locked=self.is_locked,
755
inconsistency_fatal=False),
624
parents=True, is_locked=self.is_locked),
756
625
access=self._pack_collection.text_index.data_access)
757
626
# No parents, individual CHK pages don't have specific ancestry
758
627
self.chk_bytes = GroupCompressVersionedFiles(
759
628
_GCGraphIndex(self._pack_collection.chk_index.combined_index,
760
629
add_callback=self._pack_collection.chk_index.add_callback,
761
parents=False, is_locked=self.is_locked,
762
inconsistency_fatal=False),
630
parents=False, is_locked=self.is_locked),
763
631
access=self._pack_collection.chk_index.data_access)
764
search_key_name = self._format._serializer.search_key_name
765
search_key_func = chk_map.search_key_registry.get(search_key_name)
766
self.chk_bytes._search_key_func = search_key_func
767
632
# True when the repository object is 'write locked' (as opposed to the
768
633
# physical lock only taken out around changes to the pack-names list.)
769
634
# Another way to represent this would be a decorator around the control
792
657
return self._inventory_add_lines(revision_id, parents,
793
658
inv_lines, check_content=False)
795
def _create_inv_from_null(self, delta, revision_id):
796
"""This will mutate new_inv directly.
798
This is a simplified form of create_by_apply_delta which knows that all
799
the old values must be None, so everything is a create.
801
serializer = self._format._serializer
802
new_inv = inventory.CHKInventory(serializer.search_key_name)
803
new_inv.revision_id = revision_id
804
entry_to_bytes = new_inv._entry_to_bytes
805
id_to_entry_dict = {}
806
parent_id_basename_dict = {}
807
for old_path, new_path, file_id, entry in delta:
808
if old_path is not None:
809
raise ValueError('Invalid delta, somebody tried to delete %r'
810
' from the NULL_REVISION'
811
% ((old_path, file_id),))
813
raise ValueError('Invalid delta, delta from NULL_REVISION has'
814
' no new_path %r' % (file_id,))
816
new_inv.root_id = file_id
817
parent_id_basename_key = StaticTuple('', '').intern()
819
utf8_entry_name = entry.name.encode('utf-8')
820
parent_id_basename_key = StaticTuple(entry.parent_id,
821
utf8_entry_name).intern()
822
new_value = entry_to_bytes(entry)
824
# new_inv._path_to_fileid_cache[new_path] = file_id
825
key = StaticTuple(file_id).intern()
826
id_to_entry_dict[key] = new_value
827
parent_id_basename_dict[parent_id_basename_key] = file_id
829
new_inv._populate_from_dicts(self.chk_bytes, id_to_entry_dict,
830
parent_id_basename_dict, maximum_size=serializer.maximum_size)
833
660
def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
834
661
parents, basis_inv=None, propagate_caches=False):
835
662
"""Add a new inventory expressed as a delta against another revision.
855
682
repository format specific) of the serialized inventory, and the
856
683
resulting inventory.
685
if basis_revision_id == _mod_revision.NULL_REVISION:
686
return KnitPackRepository.add_inventory_by_delta(self,
687
basis_revision_id, delta, new_revision_id, parents)
858
688
if not self.is_in_write_group():
859
689
raise AssertionError("%r not in write group" % (self,))
860
690
_mod_revision.check_not_reserved_id(new_revision_id)
862
if basis_inv is None:
863
if basis_revision_id == _mod_revision.NULL_REVISION:
864
new_inv = self._create_inv_from_null(delta, new_revision_id)
865
if new_inv.root_id is None:
866
raise errors.RootMissing()
867
inv_lines = new_inv.to_lines()
868
return self._inventory_add_lines(new_revision_id, parents,
869
inv_lines, check_content=False), new_inv
871
basis_tree = self.revision_tree(basis_revision_id)
872
basis_tree.lock_read()
691
basis_tree = self.revision_tree(basis_revision_id)
692
basis_tree.lock_read()
694
if basis_inv is None:
873
695
basis_inv = basis_tree.inventory
875
696
result = basis_inv.create_by_apply_delta(delta, new_revision_id,
876
697
propagate_caches=propagate_caches)
877
698
inv_lines = result.to_lines()
878
699
return self._inventory_add_lines(new_revision_id, parents,
879
700
inv_lines, check_content=False), result
881
if basis_tree is not None:
884
def _deserialise_inventory(self, revision_id, bytes):
885
return inventory.CHKInventory.deserialise(self.chk_bytes, bytes,
888
def _iter_inventories(self, revision_ids, ordering):
704
def _iter_inventories(self, revision_ids):
889
705
"""Iterate over many inventory objects."""
891
ordering = 'unordered'
892
706
keys = [(revision_id,) for revision_id in revision_ids]
893
stream = self.inventories.get_record_stream(keys, ordering, True)
707
stream = self.inventories.get_record_stream(keys, 'unordered', True)
895
709
for record in stream:
896
710
if record.storage_kind != 'absent':
901
715
yield inventory.CHKInventory.deserialise(self.chk_bytes, texts[key], key)
903
def _iter_inventory_xmls(self, revision_ids, ordering):
904
# Without a native 'xml' inventory, this method doesn't make sense.
905
# However older working trees, and older bundles want it - so we supply
906
# it allowing _get_inventory_xml to work. Bundles currently use the
907
# serializer directly; this also isn't ideal, but there isn't an xml
908
# iteration interface offered at all for repositories. We could make
909
# _iter_inventory_xmls be part of the contract, even if kept private.
910
inv_to_str = self._serializer.write_inventory_to_string
911
for inv in self.iter_inventories(revision_ids, ordering=ordering):
912
yield inv_to_str(inv), inv.revision_id
914
def _find_present_inventory_keys(self, revision_keys):
915
parent_map = self.inventories.get_parent_map(revision_keys)
916
present_inventory_keys = set(k for k in parent_map)
917
return present_inventory_keys
717
def _iter_inventory_xmls(self, revision_ids):
718
# Without a native 'xml' inventory, this method doesn't make sense, so
719
# make it raise to trap naughty direct users.
720
raise NotImplementedError(self._iter_inventory_xmls)
722
def _find_revision_outside_set(self, revision_ids):
723
revision_set = frozenset(revision_ids)
724
for revid in revision_ids:
725
parent_ids = self.get_parent_map([revid]).get(revid, ())
726
for parent in parent_ids:
727
if parent in revision_set:
728
# Parent is not outside the set
730
if parent not in self.get_parent_map([parent]):
734
return _mod_revision.NULL_REVISION
736
def _find_file_keys_to_fetch(self, revision_ids, pb):
737
rich_root = self.supports_rich_root()
738
revision_outside_set = self._find_revision_outside_set(revision_ids)
739
if revision_outside_set == _mod_revision.NULL_REVISION:
740
uninteresting_root_keys = set()
742
uninteresting_inv = self.get_inventory(revision_outside_set)
743
uninteresting_root_keys = set([uninteresting_inv.id_to_entry.key()])
744
interesting_root_keys = set()
745
for idx, inv in enumerate(self.iter_inventories(revision_ids)):
746
interesting_root_keys.add(inv.id_to_entry.key())
747
revision_ids = frozenset(revision_ids)
748
file_id_revisions = {}
749
bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key
750
for record, items in chk_map.iter_interesting_nodes(self.chk_bytes,
751
interesting_root_keys, uninteresting_root_keys,
753
# This is cheating a bit to use the last grabbed 'inv', but it
755
for name, bytes in items:
756
(name_utf8, file_id, revision_id) = bytes_to_info(bytes)
757
if not rich_root and name_utf8 == '':
759
if revision_id in revision_ids:
760
# Would we rather build this up into file_id => revision
763
file_id_revisions[file_id].add(revision_id)
765
file_id_revisions[file_id] = set([revision_id])
766
for file_id, revisions in file_id_revisions.iteritems():
767
yield ('file', file_id, revisions)
919
769
def fileids_altered_by_revision_ids(self, revision_ids, _inv_weave=None):
920
770
"""Find the file ids and versions affected by revisions.
926
776
revision_ids. Each altered file-ids has the exact revision_ids that
927
777
altered it listed explicitly.
929
rich_root = self.supports_rich_root()
930
bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key
931
file_id_revisions = {}
779
rich_roots = self.supports_rich_root()
932
781
pb = ui.ui_factory.nested_progress_bar()
934
revision_keys = [(r,) for r in revision_ids]
935
parent_keys = self._find_parent_keys_of_revisions(revision_keys)
936
# TODO: instead of using _find_present_inventory_keys, change the
937
# code paths to allow missing inventories to be tolerated.
938
# However, we only want to tolerate missing parent
939
# inventories, not missing inventories for revision_ids
940
present_parent_inv_keys = self._find_present_inventory_keys(
942
present_parent_inv_ids = set(
943
[k[-1] for k in present_parent_inv_keys])
944
inventories_to_read = set(revision_ids)
945
inventories_to_read.update(present_parent_inv_ids)
946
root_key_info = _build_interesting_key_sets(
947
self, inventories_to_read, present_parent_inv_ids)
948
interesting_root_keys = root_key_info.interesting_root_keys
949
uninteresting_root_keys = root_key_info.uninteresting_root_keys
950
chk_bytes = self.chk_bytes
951
for record, items in chk_map.iter_interesting_nodes(chk_bytes,
952
interesting_root_keys, uninteresting_root_keys,
954
for name, bytes in items:
955
(name_utf8, file_id, revision_id) = bytes_to_info(bytes)
956
# TODO: consider interning file_id, revision_id here, or
957
# pushing that intern() into bytes_to_info()
958
# TODO: rich_root should always be True here, for all
959
# repositories that support chk_bytes
960
if not rich_root and name_utf8 == '':
963
file_id_revisions[file_id].add(revision_id)
965
file_id_revisions[file_id] = set([revision_id])
783
total = len(revision_ids)
784
for pos, inv in enumerate(self.iter_inventories(revision_ids)):
785
pb.update("Finding text references", pos, total)
786
for entry in inv.iter_just_entries():
787
if entry.revision != inv.revision_id:
789
if not rich_roots and entry.file_id == inv.root_id:
791
alterations = result.setdefault(entry.file_id, set([]))
792
alterations.add(entry.revision)
968
return file_id_revisions
970
797
def find_text_key_references(self):
971
798
"""Find the text key references within the repository.
1067
897
p_id_roots_set.clear()
1068
898
return ('inventories', _filtered_inv_stream())
1070
def _get_filtered_chk_streams(self, excluded_revision_keys):
900
def _get_filtered_chk_streams(self, excluded_keys):
1071
901
self._text_keys = set()
1072
excluded_revision_keys.discard(_mod_revision.NULL_REVISION)
1073
if not excluded_revision_keys:
902
excluded_keys.discard(_mod_revision.NULL_REVISION)
903
if not excluded_keys:
1074
904
uninteresting_root_keys = set()
1075
905
uninteresting_pid_root_keys = set()
1077
# filter out any excluded revisions whose inventories are not
1079
# TODO: Update Repository.iter_inventories() to add
1080
# ignore_missing=True
1081
present_keys = self.from_repository._find_present_inventory_keys(
1082
excluded_revision_keys)
1083
present_ids = [k[-1] for k in present_keys]
1084
907
uninteresting_root_keys = set()
1085
908
uninteresting_pid_root_keys = set()
1086
for inv in self.from_repository.iter_inventories(present_ids):
909
for inv in self.from_repository.iter_inventories(excluded_keys):
1087
910
uninteresting_root_keys.add(inv.id_to_entry.key())
1088
911
uninteresting_pid_root_keys.add(
1089
912
inv.parent_id_basename_to_file_id.key())
913
bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key
1090
914
chk_bytes = self.from_repository.chk_bytes
1091
915
def _filter_id_to_entry():
1092
interesting_nodes = chk_map.iter_interesting_nodes(chk_bytes,
1093
self._chk_id_roots, uninteresting_root_keys)
1094
for record in _filter_text_keys(interesting_nodes, self._text_keys,
1095
chk_map._bytes_to_text_key):
916
for record, items in chk_map.iter_interesting_nodes(chk_bytes,
917
self._chk_id_roots, uninteresting_root_keys):
918
for name, bytes in items:
919
# Note: we don't care about name_utf8, because we are always
921
_, file_id, revision_id = bytes_to_info(bytes)
922
self._text_keys.add((file_id, revision_id))
1096
923
if record is not None:
1099
self._chk_id_roots = None
1100
925
yield 'chk_bytes', _filter_id_to_entry()
1101
926
def _get_parent_id_basename_to_file_id_pages():
1102
927
for record, items in chk_map.iter_interesting_nodes(chk_bytes,
1103
928
self._chk_p_id_roots, uninteresting_pid_root_keys):
1104
929
if record is not None:
1107
self._chk_p_id_roots = None
1108
931
yield 'chk_bytes', _get_parent_id_basename_to_file_id_pages()
933
def _get_text_stream(self):
934
# Note: We know we don't have to handle adding root keys, because both
935
# the source and target are GCCHK, and those always support rich-roots
936
# We may want to request as 'unordered', in case the source has done a
938
return ('texts', self.from_repository.texts.get_record_stream(
939
self._text_keys, 'groupcompress', False))
1110
941
def get_stream(self, search):
1111
def wrap_and_count(pb, rc, stream):
1112
"""Yield records from stream while showing progress."""
1114
for record in stream:
1115
if count == rc.STEP:
1117
pb.update('Estimate', rc.current, rc.max)
1122
942
revision_ids = search.get_keys()
1123
pb = ui.ui_factory.nested_progress_bar()
1124
rc = self._record_counter
1125
self._record_counter.setup(len(revision_ids))
1126
943
for stream_info in self._fetch_revision_texts(revision_ids):
1127
yield (stream_info[0],
1128
wrap_and_count(pb, rc, stream_info[1]))
1129
945
self._revision_keys = [(rev_id,) for rev_id in revision_ids]
1130
self.from_repository.revisions.clear_cache()
1131
self.from_repository.signatures.clear_cache()
1132
s = self._get_inventory_stream(self._revision_keys)
1133
yield (s[0], wrap_and_count(pb, rc, s[1]))
1134
self.from_repository.inventories.clear_cache()
1135
# TODO: The keys to exclude might be part of the search recipe
1136
# For now, exclude all parents that are at the edge of ancestry, for
1137
# which we have inventories
1138
from_repo = self.from_repository
1139
parent_keys = from_repo._find_parent_keys_of_revisions(
1140
self._revision_keys)
1141
for stream_info in self._get_filtered_chk_streams(parent_keys):
1142
yield (stream_info[0], wrap_and_count(pb, rc, stream_info[1]))
1143
self.from_repository.chk_bytes.clear_cache()
1144
s = self._get_text_stream()
1145
yield (s[0], wrap_and_count(pb, rc, s[1]))
1146
self.from_repository.texts.clear_cache()
1147
pb.update('Done', rc.max, rc.max)
1150
def get_stream_for_missing_keys(self, missing_keys):
1151
# missing keys can only occur when we are byte copying and not
1152
# translating (because translation means we don't send
1153
# unreconstructable deltas ever).
1154
missing_inventory_keys = set()
1155
for key in missing_keys:
1156
if key[0] != 'inventories':
1157
raise AssertionError('The only missing keys we should'
1158
' be filling in are inventory keys, not %s'
1160
missing_inventory_keys.add(key[1:])
1161
if self._chk_id_roots or self._chk_p_id_roots:
1162
raise AssertionError('Cannot call get_stream_for_missing_keys'
1163
' until all of get_stream() has been consumed.')
1164
# Yield the inventory stream, so we can find the chk stream
1165
# Some of the missing_keys will be missing because they are ghosts.
1166
# As such, we can ignore them. The Sink is required to verify there are
1167
# no unavailable texts when the ghost inventories are not filled in.
1168
yield self._get_inventory_stream(missing_inventory_keys,
1170
# We use the empty set for excluded_revision_keys, to make it clear
1171
# that we want to transmit all referenced chk pages.
1172
for stream_info in self._get_filtered_chk_streams(set()):
946
yield self._get_filtered_inv_stream()
947
# The keys to exclude are part of the search recipe
948
_, _, exclude_keys, _ = search.get_recipe()
949
for stream_info in self._get_filtered_chk_streams(exclude_keys):
1173
950
yield stream_info
1176
class _InterestingKeyInfo(object):
1178
self.interesting_root_keys = set()
1179
self.interesting_pid_root_keys = set()
1180
self.uninteresting_root_keys = set()
1181
self.uninteresting_pid_root_keys = set()
1183
def all_interesting(self):
1184
return self.interesting_root_keys.union(self.interesting_pid_root_keys)
1186
def all_uninteresting(self):
1187
return self.uninteresting_root_keys.union(
1188
self.uninteresting_pid_root_keys)
1191
return self.all_interesting().union(self.all_uninteresting())
1194
def _build_interesting_key_sets(repo, inventory_ids, parent_only_inv_ids):
1195
result = _InterestingKeyInfo()
1196
for inv in repo.iter_inventories(inventory_ids, 'unordered'):
1197
root_key = inv.id_to_entry.key()
1198
pid_root_key = inv.parent_id_basename_to_file_id.key()
1199
if inv.revision_id in parent_only_inv_ids:
1200
result.uninteresting_root_keys.add(root_key)
1201
result.uninteresting_pid_root_keys.add(pid_root_key)
1203
result.interesting_root_keys.add(root_key)
1204
result.interesting_pid_root_keys.add(pid_root_key)
1208
def _filter_text_keys(interesting_nodes_iterable, text_keys, bytes_to_text_key):
1209
"""Iterate the result of iter_interesting_nodes, yielding the records
1210
and adding to text_keys.
1212
text_keys_update = text_keys.update
1213
for record, items in interesting_nodes_iterable:
1214
text_keys_update([bytes_to_text_key(b) for n,b in items])
951
yield self._get_text_stream()
1220
954
class RepositoryFormatCHK1(RepositoryFormatPack):
1221
955
"""A hashed CHK+group compress pack repository."""
1223
957
repository_class = CHKInventoryRepository
1224
supports_external_lookups = True
1225
958
supports_chks = True
1226
959
# For right now, setting this to True gives us InterModel1And2 rather
1227
960
# than InterDifferingSerializer
1261
993
return ("Development repository format - rich roots, group compression"
1262
994
" and chk inventories")
1265
class RepositoryFormatCHK2(RepositoryFormatCHK1):
1266
"""A CHK repository that uses the bencode revision serializer."""
1268
_serializer = chk_serializer.chk_bencode_serializer
1270
def _get_matching_bzrdir(self):
1271
return bzrdir.format_registry.make_bzrdir('development7-rich-root')
1273
def _ignore_setting_bzrdir(self, format):
1276
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
1278
def get_format_string(self):
1279
"""See RepositoryFormat.get_format_string()."""
1280
return ('Bazaar development format - chk repository with bencode '
1281
'revision serialization (needs bzr.dev from 1.16)\n')
1284
class RepositoryFormat2a(RepositoryFormatCHK2):
1285
"""A CHK repository that uses the bencode revision serializer.
1287
This is the same as RepositoryFormatCHK2 but with a public name.
1290
_serializer = chk_serializer.chk_bencode_serializer
1292
def _get_matching_bzrdir(self):
1293
return bzrdir.format_registry.make_bzrdir('2a')
1295
def _ignore_setting_bzrdir(self, format):
1298
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
1300
def get_format_string(self):
1301
return ('Bazaar repository format 2a (needs bzr 1.16 or later)\n')
1303
def get_format_description(self):
1304
"""See RepositoryFormat.get_format_description()."""
1305
return ("Repository format 2a - rich roots, group compression"
1306
" and chk inventories")
996
def check_conversion_target(self, target_format):
997
if not target_format.rich_root_data:
998
raise errors.BadConversionTarget(
999
'Does not support rich root data.', target_format)
1000
if not getattr(target_format, 'supports_tree_reference', False):
1001
raise errors.BadConversionTarget(
1002
'Does not support nested trees', target_format)
added
removed
bzrlib/repofmt/groupcompress_repo.py
