← 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 01:53:52 UTC
  • mto: This revision was merged to the branch mainline in revision 5802.
  • Revision ID: mbp@sourcefrog.net-20110419015352-s1vdqlhuv49482gj
Reinstate checkin alias for commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/knitrepo.py
16
16
 
17
17
from bzrlib.lazy_import import lazy_import
18
18
lazy_import(globals(), """
19
 
import itertools
20
 
 
21
19
from bzrlib import (
22
20
    bzrdir,
23
21
    errors,
36
34
""")
37
35
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
36
from bzrlib.repository import (
 
37
    CommitBuilder,
39
38
    InterRepository,
 
39
    InterSameDataRepository,
40
40
    IsInWriteGroupError,
 
41
    MetaDirRepository,
 
42
    MetaDirRepositoryFormat,
41
43
    RepositoryFormat,
42
 
    )
43
 
from bzrlib.vf_repository import (
44
 
    InterSameDataRepository,
45
 
    MetaDirVersionedFileRepository,
46
 
    MetaDirVersionedFileRepositoryFormat,
47
 
    VersionedFileCommitBuilder,
48
 
    VersionedFileRootCommitBuilder,
 
44
    RootCommitBuilder,
49
45
    )
50
46
from bzrlib import symbol_versioning
51
47
 
107
103
        return result
108
104
 
109
105
 
110
 
class KnitRepository(MetaDirVersionedFileRepository):
 
106
class KnitRepository(MetaDirRepository):
111
107
    """Knit format repository."""
112
108
 
113
109
    # These attributes are inherited from the Repository base class. Setting
119
115
 
120
116
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
121
117
        _serializer):
122
 
        super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
 
118
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
123
119
        self._commit_builder_class = _commit_builder_class
124
120
        self._serializer = _serializer
125
121
        self._reconcile_fixes_text_parents = True
181
177
        result.get_parent_map([('A',)])
182
178
        return result
183
179
 
 
180
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
181
        """Find file_id(s) which are involved in the changes between revisions.
 
182
 
 
183
        This determines the set of revisions which are involved, and then
 
184
        finds all file ids affected by those revisions.
 
185
        """
 
186
        vf = self._get_revision_vf()
 
187
        from_set = set(vf.get_ancestry(from_revid))
 
188
        to_set = set(vf.get_ancestry(to_revid))
 
189
        changed = to_set.difference(from_set)
 
190
        return self._fileid_involved_by_set(changed)
 
191
 
 
192
    def fileid_involved(self, last_revid=None):
 
193
        """Find all file_ids modified in the ancestry of last_revid.
 
194
 
 
195
        :param last_revid: If None, last_revision() will be used.
 
196
        """
 
197
        if not last_revid:
 
198
            changed = set(self.all_revision_ids())
 
199
        else:
 
200
            changed = set(self.get_ancestry(last_revid))
 
201
        if None in changed:
 
202
            changed.remove(None)
 
203
        return self._fileid_involved_by_set(changed)
 
204
 
184
205
    @needs_read_lock
185
206
    def get_revision(self, revision_id):
186
207
        """Return the Revision object for a named revision"""
211
232
    def _make_parents_provider(self):
212
233
        return _KnitsParentsProvider(self.revisions)
213
234
 
214
 
 
215
 
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
 
235
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
236
        """Find revisions with different parent lists in the revision object
 
237
        and in the index graph.
 
238
 
 
239
        :param revisions_iterator: None, or an iterator of (revid,
 
240
            Revision-or-None). This iterator controls the revisions checked.
 
241
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
 
242
            parents-in-revision).
 
243
        """
 
244
        if not self.is_locked():
 
245
            raise AssertionError()
 
246
        vf = self.revisions
 
247
        if revisions_iterator is None:
 
248
            revisions_iterator = self._iter_revisions(None)
 
249
        for revid, revision in revisions_iterator:
 
250
            if revision is None:
 
251
                pass
 
252
            parent_map = vf.get_parent_map([(revid,)])
 
253
            parents_according_to_index = tuple(parent[-1] for parent in
 
254
                parent_map[(revid,)])
 
255
            parents_according_to_revision = tuple(revision.parent_ids)
 
256
            if parents_according_to_index != parents_according_to_revision:
 
257
                yield (revid, parents_according_to_index,
 
258
                    parents_according_to_revision)
 
259
 
 
260
    def _check_for_inconsistent_revision_parents(self):
 
261
        inconsistencies = list(self._find_inconsistent_revision_parents())
 
262
        if inconsistencies:
 
263
            raise errors.BzrCheckError(
 
264
                "Revision knit has inconsistent parents.")
 
265
 
 
266
 
 
267
class RepositoryFormatKnit(MetaDirRepositoryFormat):
216
268
    """Bzr repository knit format (generalized).
217
269
 
218
270
    This repository format has:
248
300
    _fetch_uses_deltas = True
249
301
    fast_deltas = False
250
302
    supports_funky_characters = True
 
303
    supports_full_versioned_files = True
251
304
    # The revision.kndx could potentially claim a revision has a different
252
305
    # parent to the revision text.
253
306
    revision_graph_can_have_wrong_parents = True
359
412
    """
360
413
 
361
414
    repository_class = KnitRepository
362
 
    _commit_builder_class = VersionedFileCommitBuilder
 
415
    _commit_builder_class = CommitBuilder
363
416
    @property
364
417
    def _serializer(self):
365
418
        return xml5.serializer_v5
393
446
    """
394
447
 
395
448
    repository_class = KnitRepository
396
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
449
    _commit_builder_class = RootCommitBuilder
397
450
    rich_root_data = True
398
451
    experimental = True
399
452
    supports_tree_reference = True
435
488
    """
436
489
 
437
490
    repository_class = KnitRepository
438
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
491
    _commit_builder_class = RootCommitBuilder
439
492
    rich_root_data = True
440
493
    supports_tree_reference = False
441
494
    @property
484
537
    @needs_read_lock
485
538
    def search_missing_revision_ids(self,
486
539
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
487
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
488
 
            limit=None):
 
540
            find_ghosts=True, revision_ids=None, if_present_ids=None):
489
541
        """See InterRepository.search_missing_revision_ids()."""
490
542
        if symbol_versioning.deprecated_passed(revision_id):
491
543
            symbol_versioning.warn(
520
572
            # that against the revision records.
521
573
            result_set = set(
522
574
                self.source._eliminate_revisions_not_present(required_revisions))
523
 
        if limit is not None:
524
 
            topo_ordered = self.source.get_graph().iter_topo_order(result_set)
525
 
            result_set = set(itertools.islice(topo_ordered, limit))
526
575
        return self.source.revision_ids_to_search_result(result_set)
527
576
 
528
577