/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: Andrew Bennetts
  • Date: 2008-08-12 14:53:26 UTC
  • mto: This revision was merged to the branch mainline in revision 3624.
  • Revision ID: andrew.bennetts@canonical.com-20080812145326-yx693x2jc4rcovb7
Move the notes on writing tests out of HACKING into a new file, and improve
them.

Many of the testing notes in the HACKING file were in duplicated in two places
in that file!  This change removes that duplication.  It also adds new sections
on “Where should I put a new test?” and “TestCase and its subclasses”, and
others like “Test feature dependencies” have been expanded.  The whole document
has generally been edited to be a bit more coherent. 

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 = {}
118
130
        self._commit_builder_class = _commit_builder_class
119
131
        self._serializer = _serializer
120
132
        self._reconcile_fixes_text_parents = True
 
133
        self._fetch_uses_deltas = True
 
134
        self._fetch_order = 'topological'
121
135
 
122
136
    @needs_read_lock
123
137
    def _all_revision_ids(self):
207
221
        revision_id = osutils.safe_revision_id(revision_id)
208
222
        return self.get_revision_reconcile(revision_id)
209
223
 
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
224
    @needs_write_lock
222
225
    def reconcile(self, other=None, thorough=False):
223
226
        """Reconcile this repository."""
225
228
        reconciler = KnitReconciler(self, thorough=thorough)
226
229
        reconciler.reconcile()
227
230
        return reconciler
228
 
 
 
231
    
229
232
    def _make_parents_provider(self):
230
233
        return _KnitsParentsProvider(self.revisions)
231
234
 
232
 
    def _find_inconsistent_revision_parents(self, revisions_iterator=None):
 
235
    def _find_inconsistent_revision_parents(self):
233
236
        """Find revisions with different parent lists in the revision object
234
237
        and in the index graph.
235
238
 
236
 
        :param revisions_iterator: None, or an iterator of (revid,
237
 
            Revision-or-None). This iterator controls the revisions checked.
238
239
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
239
240
            parents-in-revision).
240
241
        """
241
242
        if not self.is_locked():
242
243
            raise AssertionError()
243
244
        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,)])
 
245
        for index_version in vf.keys():
 
246
            parent_map = vf.get_parent_map([index_version])
250
247
            parents_according_to_index = tuple(parent[-1] for parent in
251
 
                parent_map[(revid,)])
 
248
                parent_map[index_version])
 
249
            revision = self.get_revision(index_version[-1])
252
250
            parents_according_to_revision = tuple(revision.parent_ids)
253
251
            if parents_according_to_index != parents_according_to_revision:
254
 
                yield (revid, parents_according_to_index,
 
252
                yield (index_version[-1], parents_according_to_index,
255
253
                    parents_according_to_revision)
256
254
 
257
255
    def _check_for_inconsistent_revision_parents(self):
267
265
 
268
266
 
269
267
class RepositoryFormatKnit(MetaDirRepositoryFormat):
270
 
    """Bzr repository knit format (generalized).
 
268
    """Bzr repository knit format (generalized). 
271
269
 
272
270
    This repository format has:
273
271
     - knits for file texts and inventory
289
287
    _commit_builder_class = None
290
288
    # Set this attribute in derived clases to control the _serializer that the
291
289
    # repository objects will have passed to their constructor.
292
 
    @property
293
 
    def _serializer(self):
294
 
        return xml5.serializer_v5
 
290
    _serializer = xml5.serializer_v5
295
291
    # Knit based repositories handle ghosts reasonably well.
296
292
    supports_ghosts = True
297
293
    # External lookups are not supported in this format.
298
294
    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
295
 
305
296
    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)
 
297
        mapper = ConstantMapper(name)
 
298
        index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
 
299
            repo.is_write_locked, repo.is_locked)
 
300
        access = _KnitKeyAccess(repo_transport, mapper)
 
301
        return KnitVersionedFiles(index, access, annotated=False)
311
302
 
312
303
    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,
 
304
        mapper = ConstantMapper('revisions')
 
305
        index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
 
306
            repo.is_write_locked, repo.is_locked)
 
307
        access = _KnitKeyAccess(repo_transport, mapper)
 
308
        return KnitVersionedFiles(index, access, max_delta_chain=0,
318
309
            annotated=False)
319
310
 
320
311
    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,
 
312
        mapper = ConstantMapper('signatures')
 
313
        index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
 
314
            repo.is_write_locked, repo.is_locked)
 
315
        access = _KnitKeyAccess(repo_transport, mapper)
 
316
        return KnitVersionedFiles(index, access, max_delta_chain=0,
326
317
            annotated=False)
327
318
 
328
319
    def _get_texts(self, repo_transport, repo):
329
 
        mapper = versionedfile.HashEscapedPrefixMapper()
 
320
        mapper = HashEscapedPrefixMapper()
330
321
        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,
 
322
        index = _KndxIndex(base_transport, mapper, repo.get_transaction,
 
323
            repo.is_write_locked, repo.is_locked)
 
324
        access = _KnitKeyAccess(base_transport, mapper)
 
325
        return KnitVersionedFiles(index, access, max_delta_chain=200,
335
326
            annotated=True)
336
327
 
337
328
    def initialize(self, a_bzrdir, shared=False):
342
333
        :param shared: If true the repository will be initialized as a shared
343
334
                       repository.
344
335
        """
345
 
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
 
336
        mutter('creating repository in %s.', a_bzrdir.transport.base)
346
337
        dirs = ['knits']
347
338
        files = []
348
339
        utf8_files = [('format', self.get_format_string())]
349
 
 
 
340
        
350
341
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
351
342
        repo_transport = a_bzrdir.get_repository_transport(None)
352
343
        control_files = lockable_files.LockableFiles(repo_transport,
360
351
        result.revisions.get_parent_map([('A',)])
361
352
        result.signatures.get_parent_map([('A',)])
362
353
        result.unlock()
363
 
        self._run_post_repo_init_hooks(result, a_bzrdir, shared)
364
354
        return result
365
355
 
366
356
    def open(self, a_bzrdir, _found=False, _override_transport=None):
367
357
        """See RepositoryFormat.open().
368
 
 
 
358
        
369
359
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
370
360
                                    repository at a slightly different url
371
361
                                    than normal. I.e. during 'upgrade'.
387
377
        repo.signatures = self._get_signatures(repo_transport, repo)
388
378
        repo.inventories = self._get_inventories(repo_transport, repo)
389
379
        repo.texts = self._get_texts(repo_transport, repo)
390
 
        repo.chk_bytes = None
391
380
        repo._transport = repo_transport
392
381
        return repo
393
382
 
410
399
 
411
400
    repository_class = KnitRepository
412
401
    _commit_builder_class = CommitBuilder
413
 
    @property
414
 
    def _serializer(self):
415
 
        return xml5.serializer_v5
 
402
    _serializer = xml5.serializer_v5
416
403
 
417
404
    def __ne__(self, other):
418
405
        return self.__class__ is not other.__class__
425
412
        """See RepositoryFormat.get_format_description()."""
426
413
        return "Knit repository format 1"
427
414
 
 
415
    def check_conversion_target(self, target_format):
 
416
        pass
 
417
 
428
418
 
429
419
class RepositoryFormatKnit3(RepositoryFormatKnit):
430
420
    """Bzr repository knit format 3.
445
435
    repository_class = KnitRepository
446
436
    _commit_builder_class = RootCommitBuilder
447
437
    rich_root_data = True
448
 
    experimental = True
449
438
    supports_tree_reference = True
450
 
    @property
451
 
    def _serializer(self):
452
 
        return xml7.serializer_v7
 
439
    _serializer = xml7.serializer_v7
453
440
 
454
441
    def _get_matching_bzrdir(self):
455
442
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
459
446
 
460
447
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
461
448
 
 
449
    def check_conversion_target(self, target_format):
 
450
        if not target_format.rich_root_data:
 
451
            raise errors.BadConversionTarget(
 
452
                'Does not support rich root data.', target_format)
 
453
        if not getattr(target_format, 'supports_tree_reference', False):
 
454
            raise errors.BadConversionTarget(
 
455
                'Does not support nested trees', target_format)
 
456
            
462
457
    def get_format_string(self):
463
458
        """See RepositoryFormat.get_format_string()."""
464
459
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
488
483
    _commit_builder_class = RootCommitBuilder
489
484
    rich_root_data = True
490
485
    supports_tree_reference = False
491
 
    @property
492
 
    def _serializer(self):
493
 
        return xml6.serializer_v6
 
486
    _serializer = xml6.serializer_v6
494
487
 
495
488
    def _get_matching_bzrdir(self):
496
489
        return bzrdir.format_registry.make_bzrdir('rich-root')
500
493
 
501
494
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
502
495
 
 
496
    def check_conversion_target(self, target_format):
 
497
        if not target_format.rich_root_data:
 
498
            raise errors.BadConversionTarget(
 
499
                'Does not support rich root data.', target_format)
 
500
 
503
501
    def get_format_string(self):
504
502
        """See RepositoryFormat.get_format_string()."""
505
503
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'