/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 bzrlib/repofmt/knitrepo.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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 __future__ import absolute_import
18
 
 
19
 
from ..lazy_import import lazy_import
 
17
from bzrlib.lazy_import import lazy_import
20
18
lazy_import(globals(), """
21
 
import itertools
22
 
 
23
 
from breezy import (
24
 
    controldir,
 
19
from bzrlib import (
 
20
    bzrdir,
25
21
    errors,
 
22
    knit as _mod_knit,
26
23
    lockable_files,
27
24
    lockdir,
28
25
    osutils,
29
26
    revision as _mod_revision,
30
27
    trace,
31
28
    transactions,
32
 
    )
33
 
from breezy.bzr import (
34
 
    knit as _mod_knit,
35
29
    versionedfile,
36
30
    xml5,
37
31
    xml6,
38
32
    xml7,
39
33
    )
40
34
""")
41
 
from ..repository import (
42
 
    InterRepository,
43
 
    IsInWriteGroupError,
44
 
    )
45
 
from ..bzr.repository import (
46
 
    RepositoryFormatMetaDir,
47
 
    )
48
 
from ..bzr.vf_repository import (
49
 
    InterSameDataRepository,
50
 
    MetaDirVersionedFileRepository,
51
 
    MetaDirVersionedFileRepositoryFormat,
52
 
    VersionedFileCommitBuilder,
 
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,
53
45
    )
54
46
 
55
47
 
110
102
        return result
111
103
 
112
104
 
113
 
class KnitRepository(MetaDirVersionedFileRepository):
 
105
class KnitRepository(MetaDirRepository):
114
106
    """Knit format repository."""
115
107
 
116
108
    # These attributes are inherited from the Repository base class. Setting
120
112
    _commit_builder_class = None
121
113
    _serializer = None
122
114
 
123
 
    def __init__(self, _format, a_controldir, control_files, _commit_builder_class,
 
115
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
124
116
        _serializer):
125
 
        super(KnitRepository, self).__init__(_format, a_controldir, control_files)
 
117
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
126
118
        self._commit_builder_class = _commit_builder_class
127
119
        self._serializer = _serializer
128
120
        self._reconcile_fixes_text_parents = True
129
121
 
 
122
    @needs_read_lock
130
123
    def _all_revision_ids(self):
131
124
        """See Repository.all_revision_ids()."""
132
 
        with self.lock_read():
133
 
            return [key[0] for key in self.revisions.keys()]
 
125
        return [key[0] for key in self.revisions.keys()]
134
126
 
135
127
    def _activate_new_inventory(self):
136
128
        """Put a replacement inventory.new into use as inventories."""
181
173
        # Reconciling when the output has no revisions would result in no
182
174
        # writes - but we want to ensure there is an inventory for
183
175
        # compatibility with older clients that don't lazy-load.
184
 
        result.get_parent_map([(b'A',)])
 
176
        result.get_parent_map([('A',)])
185
177
        return result
186
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
 
 
204
    @needs_read_lock
187
205
    def get_revision(self, revision_id):
188
206
        """Return the Revision object for a named revision"""
189
207
        revision_id = osutils.safe_revision_id(revision_id)
190
 
        with self.lock_read():
191
 
            return self.get_revision_reconcile(revision_id)
 
208
        return self.get_revision_reconcile(revision_id)
192
209
 
193
210
    def _refresh_data(self):
194
211
        if not self.is_locked():
195
212
            return
196
 
        if self.is_in_write_group():
197
 
            raise IsInWriteGroupError(self)
198
213
        # Create a new transaction to force all knits to see the scope change.
199
214
        # This is safe because we're outside a write group.
200
215
        self.control_files._finish_transaction()
203
218
        else:
204
219
            self.control_files._set_read_transaction()
205
220
 
 
221
    @needs_write_lock
206
222
    def reconcile(self, other=None, thorough=False):
207
223
        """Reconcile this repository."""
208
 
        from breezy.reconcile import KnitReconciler
209
 
        with self.lock_write():
210
 
            reconciler = KnitReconciler(self, thorough=thorough)
211
 
            reconciler.reconcile()
212
 
            return reconciler
 
224
        from bzrlib.reconcile import KnitReconciler
 
225
        reconciler = KnitReconciler(self, thorough=thorough)
 
226
        reconciler.reconcile()
 
227
        return reconciler
213
228
 
214
229
    def _make_parents_provider(self):
215
230
        return _KnitsParentsProvider(self.revisions)
216
231
 
217
 
 
218
 
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
 
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
270
    """Bzr repository knit format (generalized).
220
271
 
221
272
    This repository format has:
250
301
    _fetch_order = 'topological'
251
302
    _fetch_uses_deltas = True
252
303
    fast_deltas = False
253
 
    supports_funky_characters = True
254
 
    # The revision.kndx could potentially claim a revision has a different
255
 
    # parent to the revision text.
256
 
    revision_graph_can_have_wrong_parents = True
257
304
 
258
305
    def _get_inventories(self, repo_transport, repo, name='inventory'):
259
306
        mapper = versionedfile.ConstantMapper(name)
287
334
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
288
335
            annotated=True)
289
336
 
290
 
    def initialize(self, a_controldir, shared=False):
 
337
    def initialize(self, a_bzrdir, shared=False):
291
338
        """Create a knit format 1 repository.
292
339
 
293
 
        :param a_controldir: bzrdir to contain the new repository; must already
 
340
        :param a_bzrdir: bzrdir to contain the new repository; must already
294
341
            be initialized.
295
342
        :param shared: If true the repository will be initialized as a shared
296
343
                       repository.
297
344
        """
298
 
        trace.mutter('creating repository in %s.', a_controldir.transport.base)
 
345
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
299
346
        dirs = ['knits']
300
347
        files = []
301
348
        utf8_files = [('format', self.get_format_string())]
302
349
 
303
 
        self._upload_blank_content(a_controldir, dirs, files, utf8_files, shared)
304
 
        repo_transport = a_controldir.get_repository_transport(None)
 
350
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
351
        repo_transport = a_bzrdir.get_repository_transport(None)
305
352
        control_files = lockable_files.LockableFiles(repo_transport,
306
353
                                'lock', lockdir.LockDir)
307
354
        transaction = transactions.WriteTransaction()
308
 
        result = self.open(a_controldir=a_controldir, _found=True)
 
355
        result = self.open(a_bzrdir=a_bzrdir, _found=True)
309
356
        result.lock_write()
310
357
        # the revision id here is irrelevant: it will not be stored, and cannot
311
358
        # already exist, we do this to create files on disk for older clients.
312
 
        result.inventories.get_parent_map([(b'A',)])
313
 
        result.revisions.get_parent_map([(b'A',)])
314
 
        result.signatures.get_parent_map([(b'A',)])
 
359
        result.inventories.get_parent_map([('A',)])
 
360
        result.revisions.get_parent_map([('A',)])
 
361
        result.signatures.get_parent_map([('A',)])
315
362
        result.unlock()
316
 
        self._run_post_repo_init_hooks(result, a_controldir, shared)
 
363
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
317
364
        return result
318
365
 
319
 
    def open(self, a_controldir, _found=False, _override_transport=None):
 
366
    def open(self, a_bzrdir, _found=False, _override_transport=None):
320
367
        """See RepositoryFormat.open().
321
368
 
322
369
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
324
371
                                    than normal. I.e. during 'upgrade'.
325
372
        """
326
373
        if not _found:
327
 
            format = RepositoryFormatMetaDir.find_format(a_controldir)
 
374
            format = RepositoryFormat.find_format(a_bzrdir)
328
375
        if _override_transport is not None:
329
376
            repo_transport = _override_transport
330
377
        else:
331
 
            repo_transport = a_controldir.get_repository_transport(None)
 
378
            repo_transport = a_bzrdir.get_repository_transport(None)
332
379
        control_files = lockable_files.LockableFiles(repo_transport,
333
380
                                'lock', lockdir.LockDir)
334
381
        repo = self.repository_class(_format=self,
335
 
                              a_controldir=a_controldir,
 
382
                              a_bzrdir=a_bzrdir,
336
383
                              control_files=control_files,
337
384
                              _commit_builder_class=self._commit_builder_class,
338
385
                              _serializer=self._serializer)
362
409
    """
363
410
 
364
411
    repository_class = KnitRepository
365
 
    _commit_builder_class = VersionedFileCommitBuilder
 
412
    _commit_builder_class = CommitBuilder
366
413
    @property
367
414
    def _serializer(self):
368
415
        return xml5.serializer_v5
370
417
    def __ne__(self, other):
371
418
        return self.__class__ is not other.__class__
372
419
 
373
 
    @classmethod
374
 
    def get_format_string(cls):
 
420
    def get_format_string(self):
375
421
        """See RepositoryFormat.get_format_string()."""
376
 
        return b"Bazaar-NG Knit Repository Format 1"
 
422
        return "Bazaar-NG Knit Repository Format 1"
377
423
 
378
424
    def get_format_description(self):
379
425
        """See RepositoryFormat.get_format_description()."""
397
443
    """
398
444
 
399
445
    repository_class = KnitRepository
400
 
    _commit_builder_class = VersionedFileCommitBuilder
 
446
    _commit_builder_class = RootCommitBuilder
401
447
    rich_root_data = True
402
448
    experimental = True
403
449
    supports_tree_reference = True
406
452
        return xml7.serializer_v7
407
453
 
408
454
    def _get_matching_bzrdir(self):
409
 
        return controldir.format_registry.make_controldir('dirstate-with-subtree')
 
455
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
410
456
 
411
457
    def _ignore_setting_bzrdir(self, format):
412
458
        pass
413
459
 
414
 
    _matchingcontroldir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
460
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
415
461
 
416
 
    @classmethod
417
 
    def get_format_string(cls):
 
462
    def get_format_string(self):
418
463
        """See RepositoryFormat.get_format_string()."""
419
 
        return b"Bazaar Knit Repository Format 3 (bzr 0.15)\n"
 
464
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
420
465
 
421
466
    def get_format_description(self):
422
467
        """See RepositoryFormat.get_format_description()."""
440
485
    """
441
486
 
442
487
    repository_class = KnitRepository
443
 
    _commit_builder_class = VersionedFileCommitBuilder
 
488
    _commit_builder_class = RootCommitBuilder
444
489
    rich_root_data = True
445
490
    supports_tree_reference = False
446
491
    @property
448
493
        return xml6.serializer_v6
449
494
 
450
495
    def _get_matching_bzrdir(self):
451
 
        return controldir.format_registry.make_controldir('rich-root')
 
496
        return bzrdir.format_registry.make_bzrdir('rich-root')
452
497
 
453
498
    def _ignore_setting_bzrdir(self, format):
454
499
        pass
455
500
 
456
 
    _matchingcontroldir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
501
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
457
502
 
458
 
    @classmethod
459
 
    def get_format_string(cls):
 
503
    def get_format_string(self):
460
504
        """See RepositoryFormat.get_format_string()."""
461
 
        return b'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
 
505
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
462
506
 
463
507
    def get_format_description(self):
464
508
        """See RepositoryFormat.get_format_description()."""
465
509
        return "Knit repository format 4"
466
 
 
467
 
 
468
 
class InterKnitRepo(InterSameDataRepository):
469
 
    """Optimised code paths between Knit based repositories."""
470
 
 
471
 
    @classmethod
472
 
    def _get_repo_format_to_test(self):
473
 
        return RepositoryFormatKnit1()
474
 
 
475
 
    @staticmethod
476
 
    def is_compatible(source, target):
477
 
        """Be compatible with known Knit formats.
478
 
 
479
 
        We don't test for the stores being of specific types because that
480
 
        could lead to confusing results, and there is no need to be
481
 
        overly general.
482
 
        """
483
 
        try:
484
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
485
 
                isinstance(target._format, RepositoryFormatKnit))
486
 
        except AttributeError:
487
 
            return False
488
 
        return are_knits and InterRepository._same_model(source, target)
489
 
 
490
 
    def search_missing_revision_ids(self,
491
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
492
 
            limit=None):
493
 
        """See InterRepository.search_missing_revision_ids()."""
494
 
        with self.lock_read():
495
 
            source_ids_set = self._present_source_revisions_for(
496
 
                revision_ids, if_present_ids)
497
 
            # source_ids is the worst possible case we may need to pull.
498
 
            # now we want to filter source_ids against what we actually
499
 
            # have in target, but don't try to check for existence where we know
500
 
            # we do not have a revision as that would be pointless.
501
 
            target_ids = set(self.target.all_revision_ids())
502
 
            possibly_present_revisions = target_ids.intersection(source_ids_set)
503
 
            actually_present_revisions = set(
504
 
                self.target._eliminate_revisions_not_present(possibly_present_revisions))
505
 
            required_revisions = source_ids_set.difference(actually_present_revisions)
506
 
            if revision_ids is not None:
507
 
                # we used get_ancestry to determine source_ids then we are assured all
508
 
                # revisions referenced are present as they are installed in topological order.
509
 
                # and the tip revision was validated by get_ancestry.
510
 
                result_set = required_revisions
511
 
            else:
512
 
                # if we just grabbed the possibly available ids, then
513
 
                # we only have an estimate of whats available and need to validate
514
 
                # that against the revision records.
515
 
                result_set = set(
516
 
                    self.source._eliminate_revisions_not_present(required_revisions))
517
 
            if limit is not None:
518
 
                topo_ordered = self.source.get_graph().iter_topo_order(result_set)
519
 
                result_set = set(itertools.islice(topo_ordered, limit))
520
 
            return self.source.revision_ids_to_search_result(result_set)
521
 
 
522
 
 
523
 
InterRepository.register_optimiser(InterKnitRepo)