/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/repofmt/knitrepo.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 01:43:31 UTC
  • mfrom: (6676 work)
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170610014331-1xalwmij33imwidq
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/repofmt/knitrepo.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from bzrlib.lazy_import import lazy_import
 
17
from __future__ import absolute_import
 
18
 
 
19
from ..lazy_import import lazy_import
18
20
lazy_import(globals(), """
19
 
from bzrlib import (
20
 
    bzrdir,
 
21
import itertools
 
22
 
 
23
from breezy import (
 
24
    controldir,
21
25
    errors,
22
 
    knit as _mod_knit,
23
26
    lockable_files,
24
27
    lockdir,
25
28
    osutils,
26
29
    revision as _mod_revision,
27
30
    trace,
28
31
    transactions,
 
32
    )
 
33
from breezy.bzr import (
 
34
    knit as _mod_knit,
29
35
    versionedfile,
30
36
    xml5,
31
37
    xml6,
32
38
    xml7,
33
39
    )
34
40
""")
35
 
from bzrlib import (
36
 
    symbol_versioning,
37
 
    )
38
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
 
from bzrlib.repository import (
40
 
    CommitBuilder,
41
 
    MetaDirRepository,
42
 
    MetaDirRepositoryFormat,
43
 
    RepositoryFormat,
44
 
    RootCommitBuilder,
 
41
from ..decorators import needs_read_lock, needs_write_lock
 
42
from ..repository import (
 
43
    InterRepository,
 
44
    IsInWriteGroupError,
 
45
    )
 
46
from ..bzr.repository import (
 
47
    RepositoryFormatMetaDir,
 
48
    )
 
49
from ..bzr.vf_repository import (
 
50
    InterSameDataRepository,
 
51
    MetaDirVersionedFileRepository,
 
52
    MetaDirVersionedFileRepositoryFormat,
 
53
    VersionedFileCommitBuilder,
 
54
    VersionedFileRootCommitBuilder,
45
55
    )
46
56
 
47
57
 
102
112
        return result
103
113
 
104
114
 
105
 
class KnitRepository(MetaDirRepository):
 
115
class KnitRepository(MetaDirVersionedFileRepository):
106
116
    """Knit format repository."""
107
117
 
108
118
    # These attributes are inherited from the Repository base class. Setting
114
124
 
115
125
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
116
126
        _serializer):
117
 
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
 
127
        super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
118
128
        self._commit_builder_class = _commit_builder_class
119
129
        self._serializer = _serializer
120
130
        self._reconcile_fixes_text_parents = True
176
186
        result.get_parent_map([('A',)])
177
187
        return result
178
188
 
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
 
 
204
189
    @needs_read_lock
205
190
    def get_revision(self, revision_id):
206
191
        """Return the Revision object for a named revision"""
210
195
    def _refresh_data(self):
211
196
        if not self.is_locked():
212
197
            return
 
198
        if self.is_in_write_group():
 
199
            raise IsInWriteGroupError(self)
213
200
        # Create a new transaction to force all knits to see the scope change.
214
201
        # This is safe because we're outside a write group.
215
202
        self.control_files._finish_transaction()
221
208
    @needs_write_lock
222
209
    def reconcile(self, other=None, thorough=False):
223
210
        """Reconcile this repository."""
224
 
        from bzrlib.reconcile import KnitReconciler
 
211
        from breezy.reconcile import KnitReconciler
225
212
        reconciler = KnitReconciler(self, thorough=thorough)
226
213
        reconciler.reconcile()
227
214
        return reconciler
229
216
    def _make_parents_provider(self):
230
217
        return _KnitsParentsProvider(self.revisions)
231
218
 
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
 
 
269
 
class RepositoryFormatKnit(MetaDirRepositoryFormat):
 
219
 
 
220
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
270
221
    """Bzr repository knit format (generalized).
271
222
 
272
223
    This repository format has:
301
252
    _fetch_order = 'topological'
302
253
    _fetch_uses_deltas = True
303
254
    fast_deltas = False
 
255
    supports_funky_characters = True
 
256
    # The revision.kndx could potentially claim a revision has a different
 
257
    # parent to the revision text.
 
258
    revision_graph_can_have_wrong_parents = True
304
259
 
305
260
    def _get_inventories(self, repo_transport, repo, name='inventory'):
306
261
        mapper = versionedfile.ConstantMapper(name)
371
326
                                    than normal. I.e. during 'upgrade'.
372
327
        """
373
328
        if not _found:
374
 
            format = RepositoryFormat.find_format(a_bzrdir)
 
329
            format = RepositoryFormatMetaDir.find_format(a_bzrdir)
375
330
        if _override_transport is not None:
376
331
            repo_transport = _override_transport
377
332
        else:
409
364
    """
410
365
 
411
366
    repository_class = KnitRepository
412
 
    _commit_builder_class = CommitBuilder
 
367
    _commit_builder_class = VersionedFileCommitBuilder
413
368
    @property
414
369
    def _serializer(self):
415
370
        return xml5.serializer_v5
417
372
    def __ne__(self, other):
418
373
        return self.__class__ is not other.__class__
419
374
 
420
 
    def get_format_string(self):
 
375
    @classmethod
 
376
    def get_format_string(cls):
421
377
        """See RepositoryFormat.get_format_string()."""
422
378
        return "Bazaar-NG Knit Repository Format 1"
423
379
 
443
399
    """
444
400
 
445
401
    repository_class = KnitRepository
446
 
    _commit_builder_class = RootCommitBuilder
 
402
    _commit_builder_class = VersionedFileRootCommitBuilder
447
403
    rich_root_data = True
448
404
    experimental = True
449
405
    supports_tree_reference = True
452
408
        return xml7.serializer_v7
453
409
 
454
410
    def _get_matching_bzrdir(self):
455
 
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
411
        return controldir.format_registry.make_bzrdir('dirstate-with-subtree')
456
412
 
457
413
    def _ignore_setting_bzrdir(self, format):
458
414
        pass
459
415
 
460
416
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
461
417
 
462
 
    def get_format_string(self):
 
418
    @classmethod
 
419
    def get_format_string(cls):
463
420
        """See RepositoryFormat.get_format_string()."""
464
421
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
465
422
 
485
442
    """
486
443
 
487
444
    repository_class = KnitRepository
488
 
    _commit_builder_class = RootCommitBuilder
 
445
    _commit_builder_class = VersionedFileRootCommitBuilder
489
446
    rich_root_data = True
490
447
    supports_tree_reference = False
491
448
    @property
493
450
        return xml6.serializer_v6
494
451
 
495
452
    def _get_matching_bzrdir(self):
496
 
        return bzrdir.format_registry.make_bzrdir('rich-root')
 
453
        return controldir.format_registry.make_bzrdir('rich-root')
497
454
 
498
455
    def _ignore_setting_bzrdir(self, format):
499
456
        pass
500
457
 
501
458
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
502
459
 
503
 
    def get_format_string(self):
 
460
    @classmethod
 
461
    def get_format_string(cls):
504
462
        """See RepositoryFormat.get_format_string()."""
505
463
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
506
464
 
507
465
    def get_format_description(self):
508
466
        """See RepositoryFormat.get_format_description()."""
509
467
        return "Knit repository format 4"
 
468
 
 
469
 
 
470
class InterKnitRepo(InterSameDataRepository):
 
471
    """Optimised code paths between Knit based repositories."""
 
472
 
 
473
    @classmethod
 
474
    def _get_repo_format_to_test(self):
 
475
        return RepositoryFormatKnit1()
 
476
 
 
477
    @staticmethod
 
478
    def is_compatible(source, target):
 
479
        """Be compatible with known Knit formats.
 
480
 
 
481
        We don't test for the stores being of specific types because that
 
482
        could lead to confusing results, and there is no need to be
 
483
        overly general.
 
484
        """
 
485
        try:
 
486
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
 
487
                isinstance(target._format, RepositoryFormatKnit))
 
488
        except AttributeError:
 
489
            return False
 
490
        return are_knits and InterRepository._same_model(source, target)
 
491
 
 
492
    @needs_read_lock
 
493
    def search_missing_revision_ids(self,
 
494
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
495
            limit=None):
 
496
        """See InterRepository.search_missing_revision_ids()."""
 
497
        source_ids_set = self._present_source_revisions_for(
 
498
            revision_ids, if_present_ids)
 
499
        # source_ids is the worst possible case we may need to pull.
 
500
        # now we want to filter source_ids against what we actually
 
501
        # have in target, but don't try to check for existence where we know
 
502
        # we do not have a revision as that would be pointless.
 
503
        target_ids = set(self.target.all_revision_ids())
 
504
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
505
        actually_present_revisions = set(
 
506
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
507
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
508
        if revision_ids is not None:
 
509
            # we used get_ancestry to determine source_ids then we are assured all
 
510
            # revisions referenced are present as they are installed in topological order.
 
511
            # and the tip revision was validated by get_ancestry.
 
512
            result_set = required_revisions
 
513
        else:
 
514
            # if we just grabbed the possibly available ids, then
 
515
            # we only have an estimate of whats available and need to validate
 
516
            # that against the revision records.
 
517
            result_set = set(
 
518
                self.source._eliminate_revisions_not_present(required_revisions))
 
519
        if limit is not None:
 
520
            topo_ordered = self.source.get_graph().iter_topo_order(result_set)
 
521
            result_set = set(itertools.islice(topo_ordered, limit))
 
522
        return self.source.revision_ids_to_search_result(result_set)
 
523
 
 
524
 
 
525
InterRepository.register_optimiser(InterKnitRepo)