← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

  • Committer: Jelmer Vernooij
  • Date: 2008-07-08 15:58:12 UTC
  • mfrom: (3353.1.4 paramiko-1.7.2-compat)
  • mto: This revision was merged to the branch mainline in revision 3531.
  • Revision ID: jelmer@samba.org-20080708155812-gacwrgs7d7n48a0d
Merge bashprompt script that prints the bzr branch nick.

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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from __future__ import absolute_import
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
17
from bzrlib.lazy_import import lazy_import
20
18
lazy_import(globals(), """
21
 
import itertools
22
 
 
23
 
from bzrlib import (
24
 
    controldir,
 
19
from bzrlib import (
 
20
    debug,
 
21
    )
 
22
from bzrlib.store import revision
 
23
from bzrlib.store.revision.knit import KnitRevisionStore
 
24
""")
 
25
from bzrlib import (
 
26
    bzrdir,
25
27
    errors,
26
 
    knit as _mod_knit,
 
28
    knit,
27
29
    lockable_files,
28
30
    lockdir,
29
31
    osutils,
30
 
    revision as _mod_revision,
31
 
    trace,
 
32
    symbol_versioning,
32
33
    transactions,
33
 
    versionedfile,
34
34
    xml5,
35
35
    xml6,
36
36
    xml7,
37
37
    )
38
 
""")
39
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
39
from bzrlib.knit import KnitVersionedFiles, _KndxIndex, _KnitKeyAccess
40
40
from bzrlib.repository import (
41
 
    InterRepository,
42
 
    IsInWriteGroupError,
43
 
    RepositoryFormatMetaDir,
44
 
    )
45
 
from bzrlib.vf_repository import (
46
 
    InterSameDataRepository,
47
 
    MetaDirVersionedFileRepository,
48
 
    MetaDirVersionedFileRepositoryFormat,
49
 
    VersionedFileCommitBuilder,
50
 
    VersionedFileRootCommitBuilder,
51
 
    )
52
 
from bzrlib import symbol_versioning
 
41
    CommitBuilder,
 
42
    MetaDirRepository,
 
43
    MetaDirRepositoryFormat,
 
44
    RepositoryFormat,
 
45
    RootCommitBuilder,
 
46
    )
 
47
import bzrlib.revision as _mod_revision
 
48
from bzrlib.store.versioned import VersionedFileStore
 
49
from bzrlib.trace import mutter, mutter_callsite
 
50
from bzrlib.util import bencode
 
51
from bzrlib.versionedfile import ConstantMapper, HashEscapedPrefixMapper
53
52
 
54
53
 
55
54
class _KnitParentsProvider(object):
60
59
    def __repr__(self):
61
60
        return 'KnitParentsProvider(%r)' % self._knit
62
61
 
 
62
    @symbol_versioning.deprecated_method(symbol_versioning.one_one)
 
63
    def get_parents(self, revision_ids):
 
64
        """See graph._StackedParentsProvider.get_parents"""
 
65
        parent_map = self.get_parent_map(revision_ids)
 
66
        return [parent_map.get(r, None) for r in revision_ids]
 
67
 
63
68
    def get_parent_map(self, keys):
64
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
69
        """See graph._StackedParentsProvider.get_parent_map"""
65
70
        parent_map = {}
66
71
        for revision_id in keys:
67
72
            if revision_id is None:
92
97
        return 'KnitsParentsProvider(%r)' % self._knit
93
98
 
94
99
    def get_parent_map(self, keys):
95
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
100
        """See graph._StackedParentsProvider.get_parent_map"""
96
101
        parent_map = self._knit.get_parent_map(
97
102
            [self._prefix + (key,) for key in keys])
98
103
        result = {}
109
114
        return result
110
115
 
111
116
 
112
 
class KnitRepository(MetaDirVersionedFileRepository):
 
117
class KnitRepository(MetaDirRepository):
113
118
    """Knit format repository."""
114
119
 
115
120
    # These attributes are inherited from the Repository base class. Setting
121
126
 
122
127
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
123
128
        _serializer):
124
 
        super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
 
129
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
125
130
        self._commit_builder_class = _commit_builder_class
126
131
        self._serializer = _serializer
127
132
        self._reconcile_fixes_text_parents = True
128
133
 
 
134
    def _warn_if_deprecated(self):
 
135
        # This class isn't deprecated
 
136
        pass
 
137
 
129
138
    @needs_read_lock
130
139
    def _all_revision_ids(self):
131
140
        """See Repository.all_revision_ids()."""
183
192
        result.get_parent_map([('A',)])
184
193
        return result
185
194
 
 
195
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
196
        """Find file_id(s) which are involved in the changes between revisions.
 
197
 
 
198
        This determines the set of revisions which are involved, and then
 
199
        finds all file ids affected by those revisions.
 
200
        """
 
201
        vf = self._get_revision_vf()
 
202
        from_set = set(vf.get_ancestry(from_revid))
 
203
        to_set = set(vf.get_ancestry(to_revid))
 
204
        changed = to_set.difference(from_set)
 
205
        return self._fileid_involved_by_set(changed)
 
206
 
 
207
    def fileid_involved(self, last_revid=None):
 
208
        """Find all file_ids modified in the ancestry of last_revid.
 
209
 
 
210
        :param last_revid: If None, last_revision() will be used.
 
211
        """
 
212
        if not last_revid:
 
213
            changed = set(self.all_revision_ids())
 
214
        else:
 
215
            changed = set(self.get_ancestry(last_revid))
 
216
        if None in changed:
 
217
            changed.remove(None)
 
218
        return self._fileid_involved_by_set(changed)
 
219
 
186
220
    @needs_read_lock
187
221
    def get_revision(self, revision_id):
188
222
        """Return the Revision object for a named revision"""
189
223
        revision_id = osutils.safe_revision_id(revision_id)
190
224
        return self.get_revision_reconcile(revision_id)
191
225
 
192
 
    def _refresh_data(self):
193
 
        if not self.is_locked():
194
 
            return
195
 
        if self.is_in_write_group():
196
 
            raise IsInWriteGroupError(self)
197
 
        # Create a new transaction to force all knits to see the scope change.
198
 
        # This is safe because we're outside a write group.
199
 
        self.control_files._finish_transaction()
200
 
        if self.is_write_locked():
201
 
            self.control_files._set_write_transaction()
202
 
        else:
203
 
            self.control_files._set_read_transaction()
204
 
 
205
226
    @needs_write_lock
206
227
    def reconcile(self, other=None, thorough=False):
207
228
        """Reconcile this repository."""
209
230
        reconciler = KnitReconciler(self, thorough=thorough)
210
231
        reconciler.reconcile()
211
232
        return reconciler
212
 
 
 
233
    
213
234
    def _make_parents_provider(self):
214
235
        return _KnitsParentsProvider(self.revisions)
215
236
 
216
 
 
217
 
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
218
 
    """Bzr repository knit format (generalized).
 
237
    def _find_inconsistent_revision_parents(self):
 
238
        """Find revisions with different parent lists in the revision object
 
239
        and in the index graph.
 
240
 
 
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
        for index_version in vf.keys():
 
248
            parent_map = vf.get_parent_map([index_version])
 
249
            parents_according_to_index = tuple(parent[-1] for parent in
 
250
                parent_map[index_version])
 
251
            revision = self.get_revision(index_version[-1])
 
252
            parents_according_to_revision = tuple(revision.parent_ids)
 
253
            if parents_according_to_index != parents_according_to_revision:
 
254
                yield (index_version[-1], 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):
 
270
    """Bzr repository knit format (generalized). 
219
271
 
220
272
    This repository format has:
221
273
     - knits for file texts and inventory
237
289
    _commit_builder_class = None
238
290
    # Set this attribute in derived clases to control the _serializer that the
239
291
    # repository objects will have passed to their constructor.
240
 
    @property
241
 
    def _serializer(self):
242
 
        return xml5.serializer_v5
 
292
    _serializer = xml5.serializer_v5
243
293
    # Knit based repositories handle ghosts reasonably well.
244
294
    supports_ghosts = True
245
295
    # External lookups are not supported in this format.
246
296
    supports_external_lookups = False
247
 
    # No CHK support.
248
 
    supports_chks = False
249
 
    _fetch_order = 'topological'
250
 
    _fetch_uses_deltas = True
251
 
    fast_deltas = False
252
 
    supports_funky_characters = True
253
 
    # The revision.kndx could potentially claim a revision has a different
254
 
    # parent to the revision text.
255
 
    revision_graph_can_have_wrong_parents = True
256
297
 
257
298
    def _get_inventories(self, repo_transport, repo, name='inventory'):
258
 
        mapper = versionedfile.ConstantMapper(name)
259
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
260
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
261
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
262
 
        return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
 
299
        mapper = ConstantMapper(name)
 
300
        index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
 
301
            repo.is_write_locked, repo.is_locked)
 
302
        access = _KnitKeyAccess(repo_transport, mapper)
 
303
        return KnitVersionedFiles(index, access, annotated=False)
263
304
 
264
305
    def _get_revisions(self, repo_transport, repo):
265
 
        mapper = versionedfile.ConstantMapper('revisions')
266
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
267
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
268
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
269
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
 
306
        mapper = ConstantMapper('revisions')
 
307
        index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
 
308
            repo.is_write_locked, repo.is_locked)
 
309
        access = _KnitKeyAccess(repo_transport, mapper)
 
310
        return KnitVersionedFiles(index, access, max_delta_chain=0,
270
311
            annotated=False)
271
312
 
272
313
    def _get_signatures(self, repo_transport, repo):
273
 
        mapper = versionedfile.ConstantMapper('signatures')
274
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
275
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
276
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
277
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
 
314
        mapper = ConstantMapper('signatures')
 
315
        index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
 
316
            repo.is_write_locked, repo.is_locked)
 
317
        access = _KnitKeyAccess(repo_transport, mapper)
 
318
        return KnitVersionedFiles(index, access, max_delta_chain=0,
278
319
            annotated=False)
279
320
 
280
321
    def _get_texts(self, repo_transport, repo):
281
 
        mapper = versionedfile.HashEscapedPrefixMapper()
 
322
        mapper = HashEscapedPrefixMapper()
282
323
        base_transport = repo_transport.clone('knits')
283
 
        index = _mod_knit._KndxIndex(base_transport, mapper,
284
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
285
 
        access = _mod_knit._KnitKeyAccess(base_transport, mapper)
286
 
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
 
324
        index = _KndxIndex(base_transport, mapper, repo.get_transaction,
 
325
            repo.is_write_locked, repo.is_locked)
 
326
        access = _KnitKeyAccess(base_transport, mapper)
 
327
        return KnitVersionedFiles(index, access, max_delta_chain=200,
287
328
            annotated=True)
288
329
 
289
330
    def initialize(self, a_bzrdir, shared=False):
294
335
        :param shared: If true the repository will be initialized as a shared
295
336
                       repository.
296
337
        """
297
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
338
        mutter('creating repository in %s.', a_bzrdir.transport.base)
298
339
        dirs = ['knits']
299
340
        files = []
300
341
        utf8_files = [('format', self.get_format_string())]
301
 
 
 
342
        
302
343
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
303
344
        repo_transport = a_bzrdir.get_repository_transport(None)
304
345
        control_files = lockable_files.LockableFiles(repo_transport,
312
353
        result.revisions.get_parent_map([('A',)])
313
354
        result.signatures.get_parent_map([('A',)])
314
355
        result.unlock()
315
 
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
316
356
        return result
317
357
 
318
358
    def open(self, a_bzrdir, _found=False, _override_transport=None):
319
359
        """See RepositoryFormat.open().
320
 
 
 
360
        
321
361
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
322
362
                                    repository at a slightly different url
323
363
                                    than normal. I.e. during 'upgrade'.
324
364
        """
325
365
        if not _found:
326
 
            format = RepositoryFormatMetaDir.find_format(a_bzrdir)
 
366
            format = RepositoryFormat.find_format(a_bzrdir)
327
367
        if _override_transport is not None:
328
368
            repo_transport = _override_transport
329
369
        else:
339
379
        repo.signatures = self._get_signatures(repo_transport, repo)
340
380
        repo.inventories = self._get_inventories(repo_transport, repo)
341
381
        repo.texts = self._get_texts(repo_transport, repo)
342
 
        repo.chk_bytes = None
343
382
        repo._transport = repo_transport
344
383
        return repo
345
384
 
361
400
    """
362
401
 
363
402
    repository_class = KnitRepository
364
 
    _commit_builder_class = VersionedFileCommitBuilder
365
 
    @property
366
 
    def _serializer(self):
367
 
        return xml5.serializer_v5
 
403
    _commit_builder_class = CommitBuilder
 
404
    _serializer = xml5.serializer_v5
368
405
 
369
406
    def __ne__(self, other):
370
407
        return self.__class__ is not other.__class__
371
408
 
372
 
    @classmethod
373
 
    def get_format_string(cls):
 
409
    def get_format_string(self):
374
410
        """See RepositoryFormat.get_format_string()."""
375
411
        return "Bazaar-NG Knit Repository Format 1"
376
412
 
378
414
        """See RepositoryFormat.get_format_description()."""
379
415
        return "Knit repository format 1"
380
416
 
 
417
    def check_conversion_target(self, target_format):
 
418
        pass
 
419
 
381
420
 
382
421
class RepositoryFormatKnit3(RepositoryFormatKnit):
383
422
    """Bzr repository knit format 3.
396
435
    """
397
436
 
398
437
    repository_class = KnitRepository
399
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
438
    _commit_builder_class = RootCommitBuilder
400
439
    rich_root_data = True
401
 
    experimental = True
402
440
    supports_tree_reference = True
403
 
    @property
404
 
    def _serializer(self):
405
 
        return xml7.serializer_v7
 
441
    _serializer = xml7.serializer_v7
406
442
 
407
443
    def _get_matching_bzrdir(self):
408
 
        return controldir.format_registry.make_bzrdir('dirstate-with-subtree')
 
444
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
409
445
 
410
446
    def _ignore_setting_bzrdir(self, format):
411
447
        pass
412
448
 
413
449
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
414
450
 
415
 
    @classmethod
416
 
    def get_format_string(cls):
 
451
    def check_conversion_target(self, target_format):
 
452
        if not target_format.rich_root_data:
 
453
            raise errors.BadConversionTarget(
 
454
                'Does not support rich root data.', target_format)
 
455
        if not getattr(target_format, 'supports_tree_reference', False):
 
456
            raise errors.BadConversionTarget(
 
457
                'Does not support nested trees', target_format)
 
458
            
 
459
    def get_format_string(self):
417
460
        """See RepositoryFormat.get_format_string()."""
418
461
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
419
462
 
439
482
    """
440
483
 
441
484
    repository_class = KnitRepository
442
 
    _commit_builder_class = VersionedFileRootCommitBuilder
 
485
    _commit_builder_class = RootCommitBuilder
443
486
    rich_root_data = True
444
487
    supports_tree_reference = False
445
 
    @property
446
 
    def _serializer(self):
447
 
        return xml6.serializer_v6
 
488
    _serializer = xml6.serializer_v6
448
489
 
449
490
    def _get_matching_bzrdir(self):
450
 
        return controldir.format_registry.make_bzrdir('rich-root')
 
491
        return bzrdir.format_registry.make_bzrdir('rich-root')
451
492
 
452
493
    def _ignore_setting_bzrdir(self, format):
453
494
        pass
454
495
 
455
496
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
456
497
 
457
 
    @classmethod
458
 
    def get_format_string(cls):
 
498
    def check_conversion_target(self, target_format):
 
499
        if not target_format.rich_root_data:
 
500
            raise errors.BadConversionTarget(
 
501
                'Does not support rich root data.', target_format)
 
502
 
 
503
    def get_format_string(self):
459
504
        """See RepositoryFormat.get_format_string()."""
460
505
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
461
506
 
462
507
    def get_format_description(self):
463
508
        """See RepositoryFormat.get_format_description()."""
464
509
        return "Knit repository format 4"
465
 
 
466
 
 
467
 
class InterKnitRepo(InterSameDataRepository):
468
 
    """Optimised code paths between Knit based repositories."""
469
 
 
470
 
    @classmethod
471
 
    def _get_repo_format_to_test(self):
472
 
        return RepositoryFormatKnit1()
473
 
 
474
 
    @staticmethod
475
 
    def is_compatible(source, target):
476
 
        """Be compatible with known Knit formats.
477
 
 
478
 
        We don't test for the stores being of specific types because that
479
 
        could lead to confusing results, and there is no need to be
480
 
        overly general.
481
 
        """
482
 
        try:
483
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
484
 
                isinstance(target._format, RepositoryFormatKnit))
485
 
        except AttributeError:
486
 
            return False
487
 
        return are_knits and InterRepository._same_model(source, target)
488
 
 
489
 
    @needs_read_lock
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
 
        source_ids_set = self._present_source_revisions_for(
495
 
            revision_ids, if_present_ids)
496
 
        # source_ids is the worst possible case we may need to pull.
497
 
        # now we want to filter source_ids against what we actually
498
 
        # have in target, but don't try to check for existence where we know
499
 
        # we do not have a revision as that would be pointless.
500
 
        target_ids = set(self.target.all_revision_ids())
501
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
502
 
        actually_present_revisions = set(
503
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
504
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
505
 
        if revision_ids is not None:
506
 
            # we used get_ancestry to determine source_ids then we are assured all
507
 
            # revisions referenced are present as they are installed in topological order.
508
 
            # and the tip revision was validated by get_ancestry.
509
 
            result_set = required_revisions
510
 
        else:
511
 
            # if we just grabbed the possibly available ids, then
512
 
            # we only have an estimate of whats available and need to validate
513
 
            # that against the revision records.
514
 
            result_set = set(
515
 
                self.source._eliminate_revisions_not_present(required_revisions))
516
 
        if limit is not None:
517
 
            topo_ordered = self.source.get_graph().iter_topo_order(result_set)
518
 
            result_set = set(itertools.islice(topo_ordered, limit))
519
 
        return self.source.revision_ids_to_search_result(result_set)
520
 
 
521
 
 
522
 
InterRepository.register_optimiser(InterKnitRepo)