← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

  • Committer: Martin Pool
  • Date: 2011-04-19 07:52:11 UTC
  • mto: This revision was merged to the branch mainline in revision 5833.
  • Revision ID: mbp@sourcefrog.net-20110419075211-3m94qorhr0rg3gzg
Add and test _RulesSearcher.get_single_value

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/knitrepo.py
32
32
    xml7,
33
33
    )
34
34
""")
35
 
from bzrlib import (
36
 
    symbol_versioning,
37
 
    )
38
35
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
36
from bzrlib.repository import (
40
37
    CommitBuilder,
 
38
    InterRepository,
 
39
    InterSameDataRepository,
 
40
    IsInWriteGroupError,
41
41
    MetaDirRepository,
42
42
    MetaDirRepositoryFormat,
43
43
    RepositoryFormat,
44
44
    RootCommitBuilder,
45
45
    )
 
46
from bzrlib import symbol_versioning
46
47
 
47
48
 
48
49
class _KnitParentsProvider(object):
210
211
    def _refresh_data(self):
211
212
        if not self.is_locked():
212
213
            return
 
214
        if self.is_in_write_group():
 
215
            raise IsInWriteGroupError(self)
213
216
        # Create a new transaction to force all knits to see the scope change.
214
217
        # This is safe because we're outside a write group.
215
218
        self.control_files._finish_transaction()
229
232
    def _make_parents_provider(self):
230
233
        return _KnitsParentsProvider(self.revisions)
231
234
 
232
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
233
 
        """Find revisions with different parent lists in the revision object
234
 
        and in the index graph.
235
 
 
236
 
        :param revisions_iterator: None, or an iterator of (revid,
237
 
            Revision-or-None). This iterator controls the revisions checked.
238
 
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
239
 
            parents-in-revision).
240
 
        """
241
 
        if not self.is_locked():
242
 
            raise AssertionError()
243
 
        vf = self.revisions
244
 
        if revisions_iterator is None:
245
 
            revisions_iterator = self._iter_revisions(None)
246
 
        for revid, revision in revisions_iterator:
247
 
            if revision is None:
248
 
                pass
249
 
            parent_map = vf.get_parent_map([(revid,)])
250
 
            parents_according_to_index = tuple(parent[-1] for parent in
251
 
                parent_map[(revid,)])
252
 
            parents_according_to_revision = tuple(revision.parent_ids)
253
 
            if parents_according_to_index != parents_according_to_revision:
254
 
                yield (revid, parents_according_to_index,
255
 
                    parents_according_to_revision)
256
 
 
257
 
    def _check_for_inconsistent_revision_parents(self):
258
 
        inconsistencies = list(self._find_inconsistent_revision_parents())
259
 
        if inconsistencies:
260
 
            raise errors.BzrCheckError(
261
 
                "Revision knit has inconsistent parents.")
262
 
 
263
 
    def revision_graph_can_have_wrong_parents(self):
264
 
        # The revision.kndx could potentially claim a revision has a different
265
 
        # parent to the revision text.
266
 
        return True
267
 
 
268
235
 
269
236
class RepositoryFormatKnit(MetaDirRepositoryFormat):
270
237
    """Bzr repository knit format (generalized).
301
268
    _fetch_order = 'topological'
302
269
    _fetch_uses_deltas = True
303
270
    fast_deltas = False
 
271
    supports_funky_characters = True
 
272
    supports_full_versioned_files = True
 
273
    # The revision.kndx could potentially claim a revision has a different
 
274
    # parent to the revision text.
 
275
    revision_graph_can_have_wrong_parents = True
304
276
 
305
277
    def _get_inventories(self, repo_transport, repo, name='inventory'):
306
278
        mapper = versionedfile.ConstantMapper(name)
507
479
    def get_format_description(self):
508
480
        """See RepositoryFormat.get_format_description()."""
509
481
        return "Knit repository format 4"
 
482
 
 
483
 
 
484
class InterKnitRepo(InterSameDataRepository):
 
485
    """Optimised code paths between Knit based repositories."""
 
486
 
 
487
    @classmethod
 
488
    def _get_repo_format_to_test(self):
 
489
        return RepositoryFormatKnit1()
 
490
 
 
491
    @staticmethod
 
492
    def is_compatible(source, target):
 
493
        """Be compatible with known Knit formats.
 
494
 
 
495
        We don't test for the stores being of specific types because that
 
496
        could lead to confusing results, and there is no need to be
 
497
        overly general.
 
498
        """
 
499
        try:
 
500
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
 
501
                isinstance(target._format, RepositoryFormatKnit))
 
502
        except AttributeError:
 
503
            return False
 
504
        return are_knits and InterRepository._same_model(source, target)
 
505
 
 
506
    @needs_read_lock
 
507
    def search_missing_revision_ids(self,
 
508
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
509
            find_ghosts=True, revision_ids=None, if_present_ids=None):
 
510
        """See InterRepository.search_missing_revision_ids()."""
 
511
        if symbol_versioning.deprecated_passed(revision_id):
 
512
            symbol_versioning.warn(
 
513
                'search_missing_revision_ids(revision_id=...) was '
 
514
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
515
                DeprecationWarning, stacklevel=2)
 
516
            if revision_ids is not None:
 
517
                raise AssertionError(
 
518
                    'revision_ids is mutually exclusive with revision_id')
 
519
            if revision_id is not None:
 
520
                revision_ids = [revision_id]
 
521
        del revision_id
 
522
        source_ids_set = self._present_source_revisions_for(
 
523
            revision_ids, if_present_ids)
 
524
        # source_ids is the worst possible case we may need to pull.
 
525
        # now we want to filter source_ids against what we actually
 
526
        # have in target, but don't try to check for existence where we know
 
527
        # we do not have a revision as that would be pointless.
 
528
        target_ids = set(self.target.all_revision_ids())
 
529
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
530
        actually_present_revisions = set(
 
531
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
532
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
533
        if revision_ids is not None:
 
534
            # we used get_ancestry to determine source_ids then we are assured all
 
535
            # revisions referenced are present as they are installed in topological order.
 
536
            # and the tip revision was validated by get_ancestry.
 
537
            result_set = required_revisions
 
538
        else:
 
539
            # if we just grabbed the possibly available ids, then
 
540
            # we only have an estimate of whats available and need to validate
 
541
            # that against the revision records.
 
542
            result_set = set(
 
543
                self.source._eliminate_revisions_not_present(required_revisions))
 
544
        return self.source.revision_ids_to_search_result(result_set)
 
545
 
 
546
 
 
547
InterRepository.register_optimiser(InterKnitRepo)