← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

  • Committer: John Arbash Meinel
  • Date: 2009-07-08 15:43:51 UTC
  • mto: This revision was merged to the branch mainline in revision 4521.
  • Revision ID: john@arbash-meinel.com-20090708154351-u0t41fwjqm28pbnu
Add comments in the finally sections as to why we want them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/knitrepo.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
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,
26
24
    lockdir,
27
25
    osutils,
28
26
    revision as _mod_revision,
29
 
    trace,
30
27
    transactions,
31
28
    versionedfile,
32
29
    xml5,
34
31
    xml7,
35
32
    )
36
33
""")
 
34
from bzrlib import (
 
35
    symbol_versioning,
 
36
    )
37
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
38
from bzrlib.repository import (
39
 
    InterRepository,
40
 
    IsInWriteGroupError,
 
39
    CommitBuilder,
 
40
    MetaDirRepository,
 
41
    MetaDirRepositoryFormat,
41
42
    RepositoryFormat,
42
 
    )
43
 
from bzrlib.vf_repository import (
44
 
    InterSameDataRepository,
45
 
    MetaDirVersionedFileRepository,
46
 
    MetaDirVersionedFileRepositoryFormat,
47
 
    VersionedFileCommitBuilder,
48
 
    VersionedFileRootCommitBuilder,
49
 
    )
50
 
from bzrlib import symbol_versioning
 
43
    RootCommitBuilder,
 
44
    )
 
45
from bzrlib.trace import mutter, mutter_callsite
51
46
 
52
47
 
53
48
class _KnitParentsProvider(object):
107
102
        return result
108
103
 
109
104
 
110
 
class KnitRepository(MetaDirVersionedFileRepository):
 
105
class KnitRepository(MetaDirRepository):
111
106
    """Knit format repository."""
112
107
 
113
108
    # These attributes are inherited from the Repository base class. Setting
119
114
 
120
115
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
121
116
        _serializer):
122
 
        super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
 
117
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
123
118
        self._commit_builder_class = _commit_builder_class
124
119
        self._serializer = _serializer
125
120
        self._reconcile_fixes_text_parents = True
181
176
        result.get_parent_map([('A',)])
182
177
        return result
183
178
 
 
179
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
180
        """Find file_id(s) which are involved in the changes between revisions.
 
181
 
 
182
        This determines the set of revisions which are involved, and then
 
183
        finds all file ids affected by those revisions.
 
184
        """
 
185
        vf = self._get_revision_vf()
 
186
        from_set = set(vf.get_ancestry(from_revid))
 
187
        to_set = set(vf.get_ancestry(to_revid))
 
188
        changed = to_set.difference(from_set)
 
189
        return self._fileid_involved_by_set(changed)
 
190
 
 
191
    def fileid_involved(self, last_revid=None):
 
192
        """Find all file_ids modified in the ancestry of last_revid.
 
193
 
 
194
        :param last_revid: If None, last_revision() will be used.
 
195
        """
 
196
        if not last_revid:
 
197
            changed = set(self.all_revision_ids())
 
198
        else:
 
199
            changed = set(self.get_ancestry(last_revid))
 
200
        if None in changed:
 
201
            changed.remove(None)
 
202
        return self._fileid_involved_by_set(changed)
 
203
 
184
204
    @needs_read_lock
185
205
    def get_revision(self, revision_id):
186
206
        """Return the Revision object for a named revision"""
190
210
    def _refresh_data(self):
191
211
        if not self.is_locked():
192
212
            return
193
 
        if self.is_in_write_group():
194
 
            raise IsInWriteGroupError(self)
195
213
        # Create a new transaction to force all knits to see the scope change.
196
214
        # This is safe because we're outside a write group.
197
215
        self.control_files._finish_transaction()
211
229
    def _make_parents_provider(self):
212
230
        return _KnitsParentsProvider(self.revisions)
213
231
 
214
 
 
215
 
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
 
232
    def _find_inconsistent_revision_parents(self):
 
233
        """Find revisions with different parent lists in the revision object
 
234
        and in the index graph.
 
235
 
 
236
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
 
237
            parents-in-revision).
 
238
        """
 
239
        if not self.is_locked():
 
240
            raise AssertionError()
 
241
        vf = self.revisions
 
242
        for index_version in vf.keys():
 
243
            parent_map = vf.get_parent_map([index_version])
 
244
            parents_according_to_index = tuple(parent[-1] for parent in
 
245
                parent_map[index_version])
 
246
            revision = self.get_revision(index_version[-1])
 
247
            parents_according_to_revision = tuple(revision.parent_ids)
 
248
            if parents_according_to_index != parents_according_to_revision:
 
249
                yield (index_version[-1], parents_according_to_index,
 
250
                    parents_according_to_revision)
 
251
 
 
252
    def _check_for_inconsistent_revision_parents(self):
 
253
        inconsistencies = list(self._find_inconsistent_revision_parents())
 
254
        if inconsistencies:
 
255
            raise errors.BzrCheckError(
 
256
                "Revision knit has inconsistent parents.")
 
257
 
 
258
    def revision_graph_can_have_wrong_parents(self):
 
259
        # The revision.kndx could potentially claim a revision has a different
 
260
        # parent to the revision text.
 
261
        return True
 
262
 
 
263
 
 
264
class RepositoryFormatKnit(MetaDirRepositoryFormat):
216
265
    """Bzr repository knit format (generalized).
217
266
 
218
267
    This repository format has:
247
296
    _fetch_order = 'topological'
248
297
    _fetch_uses_deltas = True
249
298
    fast_deltas = False
250
 
    supports_funky_characters = True
251
 
    # The revision.kndx could potentially claim a revision has a different
252
 
    # parent to the revision text.
253
 
    revision_graph_can_have_wrong_parents = True
254
299
 
255
300
    def _get_inventories(self, repo_transport, repo, name='inventory'):
256
301
        mapper = versionedfile.ConstantMapper(name)
292
337
        :param shared: If true the repository will be initialized as a shared
293
338
                       repository.
294
339
        """
295
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
340
        mutter('creating repository in %s.', a_bzrdir.transport.base)
296
341
        dirs = ['knits']
297
342
        files = []
298
343
        utf8_files = [('format', self.get_format_string())]
310
355
        result.revisions.get_parent_map([('A',)])
311
356
        result.signatures.get_parent_map([('A',)])
312
357
        result.unlock()
313
 
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
314
358
        return result
315
359
 
316
360
    def open(self, a_bzrdir, _found=False, _override_transport=None):
359
403
    """
360
404
 
361
405
    repository_class = KnitRepository
362
 
    _commit_builder_class = VersionedFileCommitBuilder
 
406
    _commit_builder_class = CommitBuilder
363
407
    @property
364
408
    def _serializer(self):
365
409
        return xml5.serializer_v5
375
419
        """See RepositoryFormat.get_format_description()."""
376
420
        return "Knit repository format 1"
377
421
 
 
422
    def check_conversion_target(self, target_format):
 
423
        pass
 
424
 
378
425
 
379
426
class RepositoryFormatKnit3(RepositoryFormatKnit):
380
427
    """Bzr repository knit format 3.
393
440
    """
394
441
 
395
442
    repository_class = KnitRepository
396
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
443
    _commit_builder_class = RootCommitBuilder
397
444
    rich_root_data = True
398
 
    experimental = True
399
445
    supports_tree_reference = True
400
446
    @property
401
447
    def _serializer(self):
409
455
 
410
456
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
411
457
 
 
458
    def check_conversion_target(self, target_format):
 
459
        if not target_format.rich_root_data:
 
460
            raise errors.BadConversionTarget(
 
461
                'Does not support rich root data.', target_format)
 
462
        if not getattr(target_format, 'supports_tree_reference', False):
 
463
            raise errors.BadConversionTarget(
 
464
                'Does not support nested trees', target_format)
 
465
 
412
466
    def get_format_string(self):
413
467
        """See RepositoryFormat.get_format_string()."""
414
468
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
435
489
    """
436
490
 
437
491
    repository_class = KnitRepository
438
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
492
    _commit_builder_class = RootCommitBuilder
439
493
    rich_root_data = True
440
494
    supports_tree_reference = False
441
495
    @property
450
504
 
451
505
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
452
506
 
 
507
    def check_conversion_target(self, target_format):
 
508
        if not target_format.rich_root_data:
 
509
            raise errors.BadConversionTarget(
 
510
                'Does not support rich root data.', target_format)
 
511
 
453
512
    def get_format_string(self):
454
513
        """See RepositoryFormat.get_format_string()."""
455
514
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
457
516
    def get_format_description(self):
458
517
        """See RepositoryFormat.get_format_description()."""
459
518
        return "Knit repository format 4"
460
 
 
461
 
 
462
 
class InterKnitRepo(InterSameDataRepository):
463
 
    """Optimised code paths between Knit based repositories."""
464
 
 
465
 
    @classmethod
466
 
    def _get_repo_format_to_test(self):
467
 
        return RepositoryFormatKnit1()
468
 
 
469
 
    @staticmethod
470
 
    def is_compatible(source, target):
471
 
        """Be compatible with known Knit formats.
472
 
 
473
 
        We don't test for the stores being of specific types because that
474
 
        could lead to confusing results, and there is no need to be
475
 
        overly general.
476
 
        """
477
 
        try:
478
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
479
 
                isinstance(target._format, RepositoryFormatKnit))
480
 
        except AttributeError:
481
 
            return False
482
 
        return are_knits and InterRepository._same_model(source, target)
483
 
 
484
 
    @needs_read_lock
485
 
    def search_missing_revision_ids(self,
486
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
487
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
488
 
            limit=None):
489
 
        """See InterRepository.search_missing_revision_ids()."""
490
 
        if symbol_versioning.deprecated_passed(revision_id):
491
 
            symbol_versioning.warn(
492
 
                'search_missing_revision_ids(revision_id=...) was '
493
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
494
 
                DeprecationWarning, stacklevel=2)
495
 
            if revision_ids is not None:
496
 
                raise AssertionError(
497
 
                    'revision_ids is mutually exclusive with revision_id')
498
 
            if revision_id is not None:
499
 
                revision_ids = [revision_id]
500
 
        del revision_id
501
 
        source_ids_set = self._present_source_revisions_for(
502
 
            revision_ids, if_present_ids)
503
 
        # source_ids is the worst possible case we may need to pull.
504
 
        # now we want to filter source_ids against what we actually
505
 
        # have in target, but don't try to check for existence where we know
506
 
        # we do not have a revision as that would be pointless.
507
 
        target_ids = set(self.target.all_revision_ids())
508
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
509
 
        actually_present_revisions = set(
510
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
511
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
512
 
        if revision_ids is not None:
513
 
            # we used get_ancestry to determine source_ids then we are assured all
514
 
            # revisions referenced are present as they are installed in topological order.
515
 
            # and the tip revision was validated by get_ancestry.
516
 
            result_set = required_revisions
517
 
        else:
518
 
            # if we just grabbed the possibly available ids, then
519
 
            # we only have an estimate of whats available and need to validate
520
 
            # that against the revision records.
521
 
            result_set = set(
522
 
                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
 
        return self.source.revision_ids_to_search_result(result_set)
527
 
 
528
 
 
529
 
InterRepository.register_optimiser(InterKnitRepo)