/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: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of 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
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
from bzrlib.lazy_import import lazy_import
18
18
lazy_import(globals(), """
19
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 (
20
26
    bzrdir,
21
27
    errors,
22
 
    knit as _mod_knit,
 
28
    knit,
23
29
    lockable_files,
24
30
    lockdir,
25
31
    osutils,
26
 
    revision as _mod_revision,
27
 
    trace,
 
32
    symbol_versioning,
28
33
    transactions,
29
 
    versionedfile,
30
34
    xml5,
31
35
    xml6,
32
36
    xml7,
33
37
    )
34
 
""")
35
 
from bzrlib import (
36
 
    symbol_versioning,
37
 
    )
38
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
39
from bzrlib.knit import KnitVersionedFiles, _KndxIndex, _KnitKeyAccess
39
40
from bzrlib.repository import (
40
41
    CommitBuilder,
41
42
    MetaDirRepository,
43
44
    RepositoryFormat,
44
45
    RootCommitBuilder,
45
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
46
52
 
47
53
 
48
54
class _KnitParentsProvider(object):
53
59
    def __repr__(self):
54
60
        return 'KnitParentsProvider(%r)' % self._knit
55
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
 
56
68
    def get_parent_map(self, keys):
57
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
69
        """See graph._StackedParentsProvider.get_parent_map"""
58
70
        parent_map = {}
59
71
        for revision_id in keys:
60
72
            if revision_id is None:
85
97
        return 'KnitsParentsProvider(%r)' % self._knit
86
98
 
87
99
    def get_parent_map(self, keys):
88
 
        """See graph.StackedParentsProvider.get_parent_map"""
 
100
        """See graph._StackedParentsProvider.get_parent_map"""
89
101
        parent_map = self._knit.get_parent_map(
90
102
            [self._prefix + (key,) for key in keys])
91
103
        result = {}
119
131
        self._serializer = _serializer
120
132
        self._reconcile_fixes_text_parents = True
121
133
 
 
134
    def _warn_if_deprecated(self):
 
135
        # This class isn't deprecated
 
136
        pass
 
137
 
122
138
    @needs_read_lock
123
139
    def _all_revision_ids(self):
124
140
        """See Repository.all_revision_ids()."""
207
223
        revision_id = osutils.safe_revision_id(revision_id)
208
224
        return self.get_revision_reconcile(revision_id)
209
225
 
210
 
    def _refresh_data(self):
211
 
        if not self.is_locked():
212
 
            return
213
 
        # Create a new transaction to force all knits to see the scope change.
214
 
        # This is safe because we're outside a write group.
215
 
        self.control_files._finish_transaction()
216
 
        if self.is_write_locked():
217
 
            self.control_files._set_write_transaction()
218
 
        else:
219
 
            self.control_files._set_read_transaction()
220
 
 
221
226
    @needs_write_lock
222
227
    def reconcile(self, other=None, thorough=False):
223
228
        """Reconcile this repository."""
225
230
        reconciler = KnitReconciler(self, thorough=thorough)
226
231
        reconciler.reconcile()
227
232
        return reconciler
228
 
 
 
233
    
229
234
    def _make_parents_provider(self):
230
235
        return _KnitsParentsProvider(self.revisions)
231
236
 
232
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
237
    def _find_inconsistent_revision_parents(self):
233
238
        """Find revisions with different parent lists in the revision object
234
239
        and in the index graph.
235
240
 
236
 
        :param revisions_iterator: None, or an iterator of (revid,
237
 
            Revision-or-None). This iterator controls the revisions checked.
238
241
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
239
242
            parents-in-revision).
240
243
        """
241
244
        if not self.is_locked():
242
245
            raise AssertionError()
243
246
        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,)])
 
247
        for index_version in vf.keys():
 
248
            parent_map = vf.get_parent_map([index_version])
250
249
            parents_according_to_index = tuple(parent[-1] for parent in
251
 
                parent_map[(revid,)])
 
250
                parent_map[index_version])
 
251
            revision = self.get_revision(index_version[-1])
252
252
            parents_according_to_revision = tuple(revision.parent_ids)
253
253
            if parents_according_to_index != parents_according_to_revision:
254
 
                yield (revid, parents_according_to_index,
 
254
                yield (index_version[-1], parents_according_to_index,
255
255
                    parents_according_to_revision)
256
256
 
257
257
    def _check_for_inconsistent_revision_parents(self):
267
267
 
268
268
 
269
269
class RepositoryFormatKnit(MetaDirRepositoryFormat):
270
 
    """Bzr repository knit format (generalized).
 
270
    """Bzr repository knit format (generalized). 
271
271
 
272
272
    This repository format has:
273
273
     - knits for file texts and inventory
289
289
    _commit_builder_class = None
290
290
    # Set this attribute in derived clases to control the _serializer that the
291
291
    # repository objects will have passed to their constructor.
292
 
    @property
293
 
    def _serializer(self):
294
 
        return xml5.serializer_v5
 
292
    _serializer = xml5.serializer_v5
295
293
    # Knit based repositories handle ghosts reasonably well.
296
294
    supports_ghosts = True
297
295
    # External lookups are not supported in this format.
298
296
    supports_external_lookups = False
299
 
    # No CHK support.
300
 
    supports_chks = False
301
 
    _fetch_order = 'topological'
302
 
    _fetch_uses_deltas = True
303
 
    fast_deltas = False
304
297
 
305
298
    def _get_inventories(self, repo_transport, repo, name='inventory'):
306
 
        mapper = versionedfile.ConstantMapper(name)
307
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
308
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
309
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
310
 
        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)
311
304
 
312
305
    def _get_revisions(self, repo_transport, repo):
313
 
        mapper = versionedfile.ConstantMapper('revisions')
314
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
315
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
316
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
317
 
        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,
318
311
            annotated=False)
319
312
 
320
313
    def _get_signatures(self, repo_transport, repo):
321
 
        mapper = versionedfile.ConstantMapper('signatures')
322
 
        index = _mod_knit._KndxIndex(repo_transport, mapper,
323
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
324
 
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
325
 
        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,
326
319
            annotated=False)
327
320
 
328
321
    def _get_texts(self, repo_transport, repo):
329
 
        mapper = versionedfile.HashEscapedPrefixMapper()
 
322
        mapper = HashEscapedPrefixMapper()
330
323
        base_transport = repo_transport.clone('knits')
331
 
        index = _mod_knit._KndxIndex(base_transport, mapper,
332
 
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
333
 
        access = _mod_knit._KnitKeyAccess(base_transport, mapper)
334
 
        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,
335
328
            annotated=True)
336
329
 
337
330
    def initialize(self, a_bzrdir, shared=False):
342
335
        :param shared: If true the repository will be initialized as a shared
343
336
                       repository.
344
337
        """
345
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
338
        mutter('creating repository in %s.', a_bzrdir.transport.base)
346
339
        dirs = ['knits']
347
340
        files = []
348
341
        utf8_files = [('format', self.get_format_string())]
349
 
 
 
342
        
350
343
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
351
344
        repo_transport = a_bzrdir.get_repository_transport(None)
352
345
        control_files = lockable_files.LockableFiles(repo_transport,
360
353
        result.revisions.get_parent_map([('A',)])
361
354
        result.signatures.get_parent_map([('A',)])
362
355
        result.unlock()
363
 
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
364
356
        return result
365
357
 
366
358
    def open(self, a_bzrdir, _found=False, _override_transport=None):
367
359
        """See RepositoryFormat.open().
368
 
 
 
360
        
369
361
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
370
362
                                    repository at a slightly different url
371
363
                                    than normal. I.e. during 'upgrade'.
387
379
        repo.signatures = self._get_signatures(repo_transport, repo)
388
380
        repo.inventories = self._get_inventories(repo_transport, repo)
389
381
        repo.texts = self._get_texts(repo_transport, repo)
390
 
        repo.chk_bytes = None
391
382
        repo._transport = repo_transport
392
383
        return repo
393
384
 
410
401
 
411
402
    repository_class = KnitRepository
412
403
    _commit_builder_class = CommitBuilder
413
 
    @property
414
 
    def _serializer(self):
415
 
        return xml5.serializer_v5
 
404
    _serializer = xml5.serializer_v5
416
405
 
417
406
    def __ne__(self, other):
418
407
        return self.__class__ is not other.__class__
425
414
        """See RepositoryFormat.get_format_description()."""
426
415
        return "Knit repository format 1"
427
416
 
 
417
    def check_conversion_target(self, target_format):
 
418
        pass
 
419
 
428
420
 
429
421
class RepositoryFormatKnit3(RepositoryFormatKnit):
430
422
    """Bzr repository knit format 3.
445
437
    repository_class = KnitRepository
446
438
    _commit_builder_class = RootCommitBuilder
447
439
    rich_root_data = True
448
 
    experimental = True
449
440
    supports_tree_reference = True
450
 
    @property
451
 
    def _serializer(self):
452
 
        return xml7.serializer_v7
 
441
    _serializer = xml7.serializer_v7
453
442
 
454
443
    def _get_matching_bzrdir(self):
455
444
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
459
448
 
460
449
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
461
450
 
 
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
            
462
459
    def get_format_string(self):
463
460
        """See RepositoryFormat.get_format_string()."""
464
461
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
488
485
    _commit_builder_class = RootCommitBuilder
489
486
    rich_root_data = True
490
487
    supports_tree_reference = False
491
 
    @property
492
 
    def _serializer(self):
493
 
        return xml6.serializer_v6
 
488
    _serializer = xml6.serializer_v6
494
489
 
495
490
    def _get_matching_bzrdir(self):
496
491
        return bzrdir.format_registry.make_bzrdir('rich-root')
500
495
 
501
496
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
502
497
 
 
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
503
    def get_format_string(self):
504
504
        """See RepositoryFormat.get_format_string()."""
505
505
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'