← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/groupcompress_repo.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/groupcompress_repo.py
1
 
# Copyright (C) 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2008, 2009, 2010 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
29
29
    knit,
30
30
    osutils,
31
31
    pack,
32
 
    remote,
33
32
    revision as _mod_revision,
34
33
    trace,
35
34
    ui,
 
35
    versionedfile,
36
36
    )
37
37
from bzrlib.btree_index import (
38
38
    BTreeGraphIndex,
39
39
    BTreeBuilder,
40
40
    )
 
41
from bzrlib.decorators import needs_write_lock
41
42
from bzrlib.groupcompress import (
42
43
    _GCGraphIndex,
43
44
    GroupCompressVersionedFiles,
263
264
        remaining_keys = set(keys)
264
265
        counter = [0]
265
266
        if self._gather_text_refs:
266
 
            bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key
267
267
            self._text_refs = set()
268
268
        def _get_referenced_stream(root_keys, parse_leaf_nodes=False):
269
269
            cur_keys = root_keys
290
290
                    # Store is None, because we know we have a LeafNode, and we
291
291
                    # just want its entries
292
292
                    for file_id, bytes in node.iteritems(None):
293
 
                        name_utf8, file_id, revision_id = bytes_to_info(bytes)
294
 
                        self._text_refs.add((file_id, revision_id))
 
293
                        self._text_refs.add(chk_map._bytes_to_text_key(bytes))
295
294
                def next_stream():
296
295
                    stream = source_vf.get_record_stream(cur_keys,
297
296
                                                         'as-requested', True)
428
427
        self._copy_stream(source_vf, target_vf, inventory_keys,
429
428
                          'inventories', self._get_filtered_inv_stream, 2)
430
429
 
 
430
    def _get_chk_vfs_for_copy(self):
 
431
        return self._build_vfs('chk', False, False)
 
432
 
431
433
    def _copy_chk_texts(self):
432
 
        source_vf, target_vf = self._build_vfs('chk', False, False)
 
434
        source_vf, target_vf = self._get_chk_vfs_for_copy()
433
435
        # TODO: This is technically spurious... if it is a performance issue,
434
436
        #       remove it
435
437
        total_keys = source_vf.keys()
581
583
        return new_pack.data_inserted() and self._data_changed
582
584
 
583
585
 
 
586
class GCCHKCanonicalizingPacker(GCCHKPacker):
 
587
    """A packer that ensures inventories have canonical-form CHK maps.
 
588
    
 
589
    Ideally this would be part of reconcile, but it's very slow and rarely
 
590
    needed.  (It repairs repositories affected by
 
591
    https://bugs.launchpad.net/bzr/+bug/522637).
 
592
    """
 
593
 
 
594
    def __init__(self, *args, **kwargs):
 
595
        super(GCCHKCanonicalizingPacker, self).__init__(*args, **kwargs)
 
596
        self._data_changed = False
 
597
    
 
598
    def _exhaust_stream(self, source_vf, keys, message, vf_to_stream, pb_offset):
 
599
        """Create and exhaust a stream, but don't insert it.
 
600
        
 
601
        This is useful to get the side-effects of generating a stream.
 
602
        """
 
603
        self.pb.update('scanning %s' % (message,), pb_offset)
 
604
        child_pb = ui.ui_factory.nested_progress_bar()
 
605
        try:
 
606
            list(vf_to_stream(source_vf, keys, message, child_pb))
 
607
        finally:
 
608
            child_pb.finished()
 
609
 
 
610
    def _copy_inventory_texts(self):
 
611
        source_vf, target_vf = self._build_vfs('inventory', True, True)
 
612
        source_chk_vf, target_chk_vf = self._get_chk_vfs_for_copy()
 
613
        inventory_keys = source_vf.keys()
 
614
        # First, copy the existing CHKs on the assumption that most of them
 
615
        # will be correct.  This will save us from having to reinsert (and
 
616
        # recompress) these records later at the cost of perhaps preserving a
 
617
        # few unused CHKs. 
 
618
        # (Iterate but don't insert _get_filtered_inv_stream to populate the
 
619
        # variables needed by GCCHKPacker._copy_chk_texts.)
 
620
        self._exhaust_stream(source_vf, inventory_keys, 'inventories',
 
621
                self._get_filtered_inv_stream, 2)
 
622
        GCCHKPacker._copy_chk_texts(self)
 
623
        # Now copy and fix the inventories, and any regenerated CHKs.
 
624
        def chk_canonicalizing_inv_stream(source_vf, keys, message, pb=None):
 
625
            return self._get_filtered_canonicalizing_inv_stream(
 
626
                source_vf, keys, message, pb, source_chk_vf, target_chk_vf)
 
627
        self._copy_stream(source_vf, target_vf, inventory_keys,
 
628
                          'inventories', chk_canonicalizing_inv_stream, 4)
 
629
 
 
630
    def _copy_chk_texts(self):
 
631
        # No-op; in this class this happens during _copy_inventory_texts.
 
632
        pass
 
633
 
 
634
    def _get_filtered_canonicalizing_inv_stream(self, source_vf, keys, message,
 
635
            pb=None, source_chk_vf=None, target_chk_vf=None):
 
636
        """Filter the texts of inventories, regenerating CHKs to make sure they
 
637
        are canonical.
 
638
        """
 
639
        total_keys = len(keys)
 
640
        target_chk_vf = versionedfile.NoDupeAddLinesDecorator(target_chk_vf)
 
641
        def _filtered_inv_stream():
 
642
            stream = source_vf.get_record_stream(keys, 'groupcompress', True)
 
643
            search_key_name = None
 
644
            for idx, record in enumerate(stream):
 
645
                # Inventories should always be with revisions; assume success.
 
646
                bytes = record.get_bytes_as('fulltext')
 
647
                chk_inv = inventory.CHKInventory.deserialise(
 
648
                    source_chk_vf, bytes, record.key)
 
649
                if pb is not None:
 
650
                    pb.update('inv', idx, total_keys)
 
651
                chk_inv.id_to_entry._ensure_root()
 
652
                if search_key_name is None:
 
653
                    # Find the name corresponding to the search_key_func
 
654
                    search_key_reg = chk_map.search_key_registry
 
655
                    for search_key_name, func in search_key_reg.iteritems():
 
656
                        if func == chk_inv.id_to_entry._search_key_func:
 
657
                            break
 
658
                canonical_inv = inventory.CHKInventory.from_inventory(
 
659
                    target_chk_vf, chk_inv,
 
660
                    maximum_size=chk_inv.id_to_entry._root_node._maximum_size,
 
661
                    search_key_name=search_key_name)
 
662
                if chk_inv.id_to_entry.key() != canonical_inv.id_to_entry.key():
 
663
                    trace.mutter(
 
664
                        'Non-canonical CHK map for id_to_entry of inv: %s '
 
665
                        '(root is %s, should be %s)' % (chk_inv.revision_id,
 
666
                        chk_inv.id_to_entry.key()[0],
 
667
                        canonical_inv.id_to_entry.key()[0]))
 
668
                    self._data_changed = True
 
669
                p_id_map = chk_inv.parent_id_basename_to_file_id
 
670
                p_id_map._ensure_root()
 
671
                canon_p_id_map = canonical_inv.parent_id_basename_to_file_id
 
672
                if p_id_map.key() != canon_p_id_map.key():
 
673
                    trace.mutter(
 
674
                        'Non-canonical CHK map for parent_id_to_basename of '
 
675
                        'inv: %s (root is %s, should be %s)'
 
676
                        % (chk_inv.revision_id, p_id_map.key()[0],
 
677
                           canon_p_id_map.key()[0]))
 
678
                    self._data_changed = True
 
679
                yield versionedfile.ChunkedContentFactory(record.key,
 
680
                        record.parents, record.sha1,
 
681
                        canonical_inv.to_lines())
 
682
            # We have finished processing all of the inventory records, we
 
683
            # don't need these sets anymore
 
684
        return _filtered_inv_stream()
 
685
 
 
686
    def _use_pack(self, new_pack):
 
687
        """Override _use_pack to check for reconcile having changed content."""
 
688
        return new_pack.data_inserted() and self._data_changed
 
689
 
 
690
 
584
691
class GCRepositoryPackCollection(RepositoryPackCollection):
585
692
 
586
693
    pack_factory = GCPack
648
755
        chk_diff = chk_map.iter_interesting_nodes(
649
756
            chk_bytes_no_fallbacks, root_key_info.interesting_root_keys,
650
757
            root_key_info.uninteresting_root_keys)
651
 
        bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key
652
758
        text_keys = set()
653
759
        try:
654
 
            for record in _filter_text_keys(chk_diff, text_keys, bytes_to_info):
 
760
            for record in _filter_text_keys(chk_diff, text_keys,
 
761
                                            chk_map._bytes_to_text_key):
655
762
                pass
656
763
        except errors.NoSuchRevision, e:
657
764
            # XXX: It would be nice if we could give a more precise error here.
705
812
                self._remove_pack_from_memory(pack)
706
813
        # record the newly available packs and stop advertising the old
707
814
        # packs
708
 
        result = self._save_pack_names(clear_obsolete_packs=True)
709
 
        # Move the old packs out of the way now they are no longer referenced.
710
 
        for revision_count, packs in pack_operations:
711
 
            self._obsolete_packs(packs)
 
815
        to_be_obsoleted = []
 
816
        for _, packs in pack_operations:
 
817
            to_be_obsoleted.extend(packs)
 
818
        result = self._save_pack_names(clear_obsolete_packs=True,
 
819
                                       obsolete_packs=to_be_obsoleted)
712
820
        return result
713
821
 
714
822
 
864
972
        if basis_inv is None:
865
973
            if basis_revision_id == _mod_revision.NULL_REVISION:
866
974
                new_inv = self._create_inv_from_null(delta, new_revision_id)
 
975
                if new_inv.root_id is None:
 
976
                    raise errors.RootMissing()
867
977
                inv_lines = new_inv.to_lines()
868
978
                return self._inventory_add_lines(new_revision_id, parents,
869
979
                    inv_lines, check_content=False), new_inv
881
991
            if basis_tree is not None:
882
992
                basis_tree.unlock()
883
993
 
884
 
    def deserialise_inventory(self, revision_id, bytes):
 
994
    def _deserialise_inventory(self, revision_id, bytes):
885
995
        return inventory.CHKInventory.deserialise(self.chk_bytes, bytes,
886
996
            (revision_id,))
887
997
 
903
1013
    def _iter_inventory_xmls(self, revision_ids, ordering):
904
1014
        # Without a native 'xml' inventory, this method doesn't make sense.
905
1015
        # However older working trees, and older bundles want it - so we supply
906
 
        # it allowing get_inventory_xml to work. Bundles currently use the
 
1016
        # it allowing _get_inventory_xml to work. Bundles currently use the
907
1017
        # serializer directly; this also isn't ideal, but there isn't an xml
908
1018
        # iteration interface offered at all for repositories. We could make
909
1019
        # _iter_inventory_xmls be part of the contract, even if kept private.
999
1109
        finally:
1000
1110
            pb.finished()
1001
1111
 
 
1112
    @needs_write_lock
 
1113
    def reconcile_canonicalize_chks(self):
 
1114
        """Reconcile this repository to make sure all CHKs are in canonical
 
1115
        form.
 
1116
        """
 
1117
        from bzrlib.reconcile import PackReconciler
 
1118
        reconciler = PackReconciler(self, thorough=True, canonicalize_chks=True)
 
1119
        reconciler.reconcile()
 
1120
        return reconciler
 
1121
 
1002
1122
    def _reconcile_pack(self, collection, packs, extension, revs, pb):
1003
1123
        packer = GCCHKReconcilePacker(collection, packs, extension)
1004
1124
        return packer.pack(pb)
1005
1125
 
 
1126
    def _canonicalize_chks_pack(self, collection, packs, extension, revs, pb):
 
1127
        packer = GCCHKCanonicalizingPacker(collection, packs, extension, revs)
 
1128
        return packer.pack(pb)
 
1129
 
1006
1130
    def _get_source(self, to_format):
1007
1131
        """Return a source for streaming from this repository."""
1008
1132
        if self._format._serializer == to_format._serializer:
1087
1211
                uninteresting_root_keys.add(inv.id_to_entry.key())
1088
1212
                uninteresting_pid_root_keys.add(
1089
1213
                    inv.parent_id_basename_to_file_id.key())
1090
 
        bytes_to_info = inventory.CHKInventory._bytes_to_utf8name_key
1091
1214
        chk_bytes = self.from_repository.chk_bytes
1092
1215
        def _filter_id_to_entry():
1093
1216
            interesting_nodes = chk_map.iter_interesting_nodes(chk_bytes,
1094
1217
                        self._chk_id_roots, uninteresting_root_keys)
1095
1218
            for record in _filter_text_keys(interesting_nodes, self._text_keys,
1096
 
                    bytes_to_info):
 
1219
                    chk_map._bytes_to_text_key):
1097
1220
                if record is not None:
1098
1221
                    yield record
1099
1222
            # Consumed
1109
1232
        yield 'chk_bytes', _get_parent_id_basename_to_file_id_pages()
1110
1233
 
1111
1234
    def get_stream(self, search):
 
1235
        def wrap_and_count(pb, rc, stream):
 
1236
            """Yield records from stream while showing progress."""
 
1237
            count = 0
 
1238
            for record in stream:
 
1239
                if count == rc.STEP:
 
1240
                    rc.increment(count)
 
1241
                    pb.update('Estimate', rc.current, rc.max)
 
1242
                    count = 0
 
1243
                count += 1
 
1244
                yield record
 
1245
 
1112
1246
        revision_ids = search.get_keys()
 
1247
        pb = ui.ui_factory.nested_progress_bar()
 
1248
        rc = self._record_counter
 
1249
        self._record_counter.setup(len(revision_ids))
1113
1250
        for stream_info in self._fetch_revision_texts(revision_ids):
1114
 
            yield stream_info
 
1251
            yield (stream_info[0],
 
1252
                wrap_and_count(pb, rc, stream_info[1]))
1115
1253
        self._revision_keys = [(rev_id,) for rev_id in revision_ids]
1116
1254
        self.from_repository.revisions.clear_cache()
1117
1255
        self.from_repository.signatures.clear_cache()
1118
 
        yield self._get_inventory_stream(self._revision_keys)
 
1256
        s = self._get_inventory_stream(self._revision_keys)
 
1257
        yield (s[0], wrap_and_count(pb, rc, s[1]))
1119
1258
        self.from_repository.inventories.clear_cache()
1120
1259
        # TODO: The keys to exclude might be part of the search recipe
1121
1260
        # For now, exclude all parents that are at the edge of ancestry, for
1124
1263
        parent_keys = from_repo._find_parent_keys_of_revisions(
1125
1264
                        self._revision_keys)
1126
1265
        for stream_info in self._get_filtered_chk_streams(parent_keys):
1127
 
            yield stream_info
 
1266
            yield (stream_info[0], wrap_and_count(pb, rc, stream_info[1]))
1128
1267
        self.from_repository.chk_bytes.clear_cache()
1129
 
        yield self._get_text_stream()
 
1268
        s = self._get_text_stream()
 
1269
        yield (s[0], wrap_and_count(pb, rc, s[1]))
1130
1270
        self.from_repository.texts.clear_cache()
 
1271
        pb.update('Done', rc.max, rc.max)
 
1272
        pb.finished()
1131
1273
 
1132
1274
    def get_stream_for_missing_keys(self, missing_keys):
1133
1275
        # missing keys can only occur when we are byte copying and not
1187
1329
    return result
1188
1330
 
1189
1331
 
1190
 
def _filter_text_keys(interesting_nodes_iterable, text_keys, bytes_to_info):
 
1332
def _filter_text_keys(interesting_nodes_iterable, text_keys, bytes_to_text_key):
1191
1333
    """Iterate the result of iter_interesting_nodes, yielding the records
1192
1334
    and adding to text_keys.
1193
1335
    """
 
1336
    text_keys_update = text_keys.update
1194
1337
    for record, items in interesting_nodes_iterable:
1195
 
        for name, bytes in items:
1196
 
            # Note: we don't care about name_utf8, because groupcompress repos
1197
 
            # are always rich-root, so there are no synthesised root records to
1198
 
            # ignore.
1199
 
            _, file_id, revision_id = bytes_to_info(bytes)
1200
 
            file_id = intern(file_id)
1201
 
            revision_id = intern(revision_id)
1202
 
            text_keys.add(StaticTuple(file_id, revision_id).intern())
 
1338
        text_keys_update([bytes_to_text_key(b) for n,b in items])
1203
1339
        yield record
1204
1340
 
1205
1341