~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

  • Committer: Alexander Belchenko
  • Date: 2008-03-12 21:07:46 UTC
  • mto: This revision was merged to the branch mainline in revision 3272.
  • Revision ID: bialix@ukr.net-20080312210746-39xx932qcb92g3lj
Significantly reducing execution time and network traffic for trivial case of `bzr missing`

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from bzrlib.lazy_import import lazy_import
 
18
lazy_import(globals(), """
 
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,
 
27
    deprecated_graph,
 
28
    errors,
 
29
    knit,
 
30
    lockable_files,
 
31
    lockdir,
 
32
    osutils,
 
33
    symbol_versioning,
 
34
    transactions,
 
35
    xml5,
 
36
    xml6,
 
37
    xml7,
 
38
    )
 
39
 
 
40
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
41
from bzrlib.repository import (
 
42
    CommitBuilder,
 
43
    MetaDirRepository,
 
44
    MetaDirRepositoryFormat,
 
45
    RepositoryFormat,
 
46
    RootCommitBuilder,
 
47
    )
 
48
import bzrlib.revision as _mod_revision
 
49
from bzrlib.store.versioned import VersionedFileStore
 
50
from bzrlib.trace import mutter, mutter_callsite
 
51
from bzrlib.util import bencode
 
52
 
 
53
 
 
54
class _KnitParentsProvider(object):
 
55
 
 
56
    def __init__(self, knit):
 
57
        self._knit = knit
 
58
 
 
59
    def __repr__(self):
 
60
        return 'KnitParentsProvider(%r)' % self._knit
 
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
 
 
68
    def get_parent_map(self, keys):
 
69
        """See graph._StackedParentsProvider.get_parent_map"""
 
70
        parent_map = {}
 
71
        for revision_id in keys:
 
72
            if revision_id == _mod_revision.NULL_REVISION:
 
73
                parent_map[revision_id] = ()
 
74
            else:
 
75
                try:
 
76
                    parents = tuple(
 
77
                        self._knit.get_parents_with_ghosts(revision_id))
 
78
                except errors.RevisionNotPresent:
 
79
                    continue
 
80
                else:
 
81
                    if len(parents) == 0:
 
82
                        parents = (_mod_revision.NULL_REVISION,)
 
83
                parent_map[revision_id] = parents
 
84
        return parent_map
 
85
 
 
86
 
 
87
class KnitRepository(MetaDirRepository):
 
88
    """Knit format repository."""
 
89
 
 
90
    # These attributes are inherited from the Repository base class. Setting
 
91
    # them to None ensures that if the constructor is changed to not initialize
 
92
    # them, or a subclass fails to call the constructor, that an error will
 
93
    # occur rather than the system working but generating incorrect data.
 
94
    _commit_builder_class = None
 
95
    _serializer = None
 
96
 
 
97
    def __init__(self, _format, a_bzrdir, control_files, _revision_store,
 
98
        control_store, text_store, _commit_builder_class, _serializer):
 
99
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files,
 
100
            _revision_store, control_store, text_store)
 
101
        self._commit_builder_class = _commit_builder_class
 
102
        self._serializer = _serializer
 
103
        self._reconcile_fixes_text_parents = True
 
104
 
 
105
    def _warn_if_deprecated(self):
 
106
        # This class isn't deprecated
 
107
        pass
 
108
 
 
109
    def _inventory_add_lines(self, inv_vf, revid, parents, lines, check_content):
 
110
        return inv_vf.add_lines_with_ghosts(revid, parents, lines,
 
111
            check_content=check_content)[0]
 
112
 
 
113
    @needs_read_lock
 
114
    def _all_revision_ids(self):
 
115
        """See Repository.all_revision_ids()."""
 
116
        # Knits get the revision graph from the index of the revision knit, so
 
117
        # it's always possible even if they're on an unlistable transport.
 
118
        return self._revision_store.all_revision_ids(self.get_transaction())
 
119
 
 
120
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
121
        """Find file_id(s) which are involved in the changes between revisions.
 
122
 
 
123
        This determines the set of revisions which are involved, and then
 
124
        finds all file ids affected by those revisions.
 
125
        """
 
126
        vf = self._get_revision_vf()
 
127
        from_set = set(vf.get_ancestry(from_revid))
 
128
        to_set = set(vf.get_ancestry(to_revid))
 
129
        changed = to_set.difference(from_set)
 
130
        return self._fileid_involved_by_set(changed)
 
131
 
 
132
    def fileid_involved(self, last_revid=None):
 
133
        """Find all file_ids modified in the ancestry of last_revid.
 
134
 
 
135
        :param last_revid: If None, last_revision() will be used.
 
136
        """
 
137
        if not last_revid:
 
138
            changed = set(self.all_revision_ids())
 
139
        else:
 
140
            changed = set(self.get_ancestry(last_revid))
 
141
        if None in changed:
 
142
            changed.remove(None)
 
143
        return self._fileid_involved_by_set(changed)
 
144
 
 
145
    @needs_read_lock
 
146
    def get_ancestry(self, revision_id, topo_sorted=True):
 
147
        """Return a list of revision-ids integrated by a revision.
 
148
        
 
149
        This is topologically sorted, unless 'topo_sorted' is specified as
 
150
        False.
 
151
        """
 
152
        if _mod_revision.is_null(revision_id):
 
153
            return [None]
 
154
        vf = self._get_revision_vf()
 
155
        try:
 
156
            return [None] + vf.get_ancestry(revision_id, topo_sorted)
 
157
        except errors.RevisionNotPresent:
 
158
            raise errors.NoSuchRevision(self, revision_id)
 
159
 
 
160
    @symbol_versioning.deprecated_method(symbol_versioning.one_two)
 
161
    @needs_read_lock
 
162
    def get_data_stream(self, revision_ids):
 
163
        """See Repository.get_data_stream.
 
164
        
 
165
        Deprecated in 1.2 for get_data_stream_for_search.
 
166
        """
 
167
        search_result = self.revision_ids_to_search_result(set(revision_ids))
 
168
        return self.get_data_stream_for_search(search_result)
 
169
 
 
170
    @needs_read_lock
 
171
    def get_data_stream_for_search(self, search):
 
172
        """See Repository.get_data_stream_for_search."""
 
173
        item_keys = self.item_keys_introduced_by(search.get_keys())
 
174
        for knit_kind, file_id, versions in item_keys:
 
175
            name = (knit_kind,)
 
176
            if knit_kind == 'file':
 
177
                name = ('file', file_id)
 
178
                knit = self.weave_store.get_weave_or_empty(
 
179
                    file_id, self.get_transaction())
 
180
            elif knit_kind == 'inventory':
 
181
                knit = self.get_inventory_weave()
 
182
            elif knit_kind == 'revisions':
 
183
                knit = self._revision_store.get_revision_file(
 
184
                    self.get_transaction())
 
185
            elif knit_kind == 'signatures':
 
186
                knit = self._revision_store.get_signature_file(
 
187
                    self.get_transaction())
 
188
            else:
 
189
                raise AssertionError('Unknown knit kind %r' % (knit_kind,))
 
190
            yield name, _get_stream_as_bytes(knit, versions)
 
191
 
 
192
    @needs_read_lock
 
193
    def get_revision(self, revision_id):
 
194
        """Return the Revision object for a named revision"""
 
195
        revision_id = osutils.safe_revision_id(revision_id)
 
196
        return self.get_revision_reconcile(revision_id)
 
197
 
 
198
    @needs_read_lock
 
199
    def get_revision_graph(self, revision_id=None):
 
200
        """Return a dictionary containing the revision graph.
 
201
 
 
202
        :param revision_id: The revision_id to get a graph from. If None, then
 
203
        the entire revision graph is returned. This is a deprecated mode of
 
204
        operation and will be removed in the future.
 
205
        :return: a dictionary of revision_id->revision_parents_list.
 
206
        """
 
207
        if 'evil' in debug.debug_flags:
 
208
            mutter_callsite(3,
 
209
                "get_revision_graph scales with size of history.")
 
210
        # special case NULL_REVISION
 
211
        if revision_id == _mod_revision.NULL_REVISION:
 
212
            return {}
 
213
        a_weave = self._get_revision_vf()
 
214
        if revision_id is None:
 
215
            return a_weave.get_graph()
 
216
        if revision_id not in a_weave:
 
217
            raise errors.NoSuchRevision(self, revision_id)
 
218
        else:
 
219
            # add what can be reached from revision_id
 
220
            return a_weave.get_graph([revision_id])
 
221
 
 
222
    @needs_read_lock
 
223
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
224
        """Return a graph of the revisions with ghosts marked as applicable.
 
225
 
 
226
        :param revision_ids: an iterable of revisions to graph or None for all.
 
227
        :return: a Graph object with the graph reachable from revision_ids.
 
228
        """
 
229
        if 'evil' in debug.debug_flags:
 
230
            mutter_callsite(3,
 
231
                "get_revision_graph_with_ghosts scales with size of history.")
 
232
        result = deprecated_graph.Graph()
 
233
        vf = self._get_revision_vf()
 
234
        versions = set(vf.versions())
 
235
        if not revision_ids:
 
236
            pending = set(self.all_revision_ids())
 
237
            required = set([])
 
238
        else:
 
239
            pending = set(revision_ids)
 
240
            # special case NULL_REVISION
 
241
            if _mod_revision.NULL_REVISION in pending:
 
242
                pending.remove(_mod_revision.NULL_REVISION)
 
243
            required = set(pending)
 
244
        done = set([])
 
245
        while len(pending):
 
246
            revision_id = pending.pop()
 
247
            if not revision_id in versions:
 
248
                if revision_id in required:
 
249
                    raise errors.NoSuchRevision(self, revision_id)
 
250
                # a ghost
 
251
                result.add_ghost(revision_id)
 
252
                # mark it as done so we don't try for it again.
 
253
                done.add(revision_id)
 
254
                continue
 
255
            parent_ids = vf.get_parents_with_ghosts(revision_id)
 
256
            for parent_id in parent_ids:
 
257
                # is this queued or done ?
 
258
                if (parent_id not in pending and
 
259
                    parent_id not in done):
 
260
                    # no, queue it.
 
261
                    pending.add(parent_id)
 
262
            result.add_node(revision_id, parent_ids)
 
263
            done.add(revision_id)
 
264
        return result
 
265
 
 
266
    def _get_revision_vf(self):
 
267
        """:return: a versioned file containing the revisions."""
 
268
        vf = self._revision_store.get_revision_file(self.get_transaction())
 
269
        return vf
 
270
 
 
271
    def _get_history_vf(self):
 
272
        """Get a versionedfile whose history graph reflects all revisions.
 
273
 
 
274
        For knit repositories, this is the revision knit.
 
275
        """
 
276
        return self._get_revision_vf()
 
277
 
 
278
    def has_revisions(self, revision_ids):
 
279
        """See Repository.has_revisions()."""
 
280
        result = set()
 
281
        transaction = self.get_transaction()
 
282
        for revision_id in revision_ids:
 
283
            if self._revision_store.has_revision_id(revision_id, transaction):
 
284
                result.add(revision_id)
 
285
        return result
 
286
 
 
287
    @needs_write_lock
 
288
    def reconcile(self, other=None, thorough=False):
 
289
        """Reconcile this repository."""
 
290
        from bzrlib.reconcile import KnitReconciler
 
291
        reconciler = KnitReconciler(self, thorough=thorough)
 
292
        reconciler.reconcile()
 
293
        return reconciler
 
294
    
 
295
    def revision_parents(self, revision_id):
 
296
        return self._get_revision_vf().get_parents(revision_id)
 
297
 
 
298
    def _make_parents_provider(self):
 
299
        return _KnitParentsProvider(self._get_revision_vf())
 
300
 
 
301
    def _find_inconsistent_revision_parents(self):
 
302
        """Find revisions with different parent lists in the revision object
 
303
        and in the index graph.
 
304
 
 
305
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
 
306
            parents-in-revision).
 
307
        """
 
308
        assert self.is_locked()
 
309
        vf = self._get_revision_vf()
 
310
        for index_version in vf.versions():
 
311
            parents_according_to_index = tuple(vf.get_parents_with_ghosts(
 
312
                index_version))
 
313
            revision = self.get_revision(index_version)
 
314
            parents_according_to_revision = tuple(revision.parent_ids)
 
315
            if parents_according_to_index != parents_according_to_revision:
 
316
                yield (index_version, parents_according_to_index,
 
317
                    parents_according_to_revision)
 
318
 
 
319
    def _check_for_inconsistent_revision_parents(self):
 
320
        inconsistencies = list(self._find_inconsistent_revision_parents())
 
321
        if inconsistencies:
 
322
            raise errors.BzrCheckError(
 
323
                "Revision knit has inconsistent parents.")
 
324
 
 
325
    def revision_graph_can_have_wrong_parents(self):
 
326
        # The revision.kndx could potentially claim a revision has a different
 
327
        # parent to the revision text.
 
328
        return True
 
329
 
 
330
 
 
331
class RepositoryFormatKnit(MetaDirRepositoryFormat):
 
332
    """Bzr repository knit format (generalized). 
 
333
 
 
334
    This repository format has:
 
335
     - knits for file texts and inventory
 
336
     - hash subdirectory based stores.
 
337
     - knits for revisions and signatures
 
338
     - TextStores for revisions and signatures.
 
339
     - a format marker of its own
 
340
     - an optional 'shared-storage' flag
 
341
     - an optional 'no-working-trees' flag
 
342
     - a LockDir lock
 
343
    """
 
344
 
 
345
    # Set this attribute in derived classes to control the repository class
 
346
    # created by open and initialize.
 
347
    repository_class = None
 
348
    # Set this attribute in derived classes to control the
 
349
    # _commit_builder_class that the repository objects will have passed to
 
350
    # their constructor.
 
351
    _commit_builder_class = None
 
352
    # Set this attribute in derived clases to control the _serializer that the
 
353
    # repository objects will have passed to their constructor.
 
354
    _serializer = xml5.serializer_v5
 
355
    # Knit based repositories handle ghosts reasonably well.
 
356
    supports_ghosts = True
 
357
    # External lookups are not supported in this format.
 
358
    supports_external_lookups = False
 
359
 
 
360
    def _get_control_store(self, repo_transport, control_files):
 
361
        """Return the control store for this repository."""
 
362
        return VersionedFileStore(
 
363
            repo_transport,
 
364
            prefixed=False,
 
365
            file_mode=control_files._file_mode,
 
366
            versionedfile_class=knit.KnitVersionedFile,
 
367
            versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
 
368
            )
 
369
 
 
370
    def _get_revision_store(self, repo_transport, control_files):
 
371
        """See RepositoryFormat._get_revision_store()."""
 
372
        versioned_file_store = VersionedFileStore(
 
373
            repo_transport,
 
374
            file_mode=control_files._file_mode,
 
375
            prefixed=False,
 
376
            precious=True,
 
377
            versionedfile_class=knit.KnitVersionedFile,
 
378
            versionedfile_kwargs={'delta':False,
 
379
                                  'factory':knit.KnitPlainFactory(),
 
380
                                 },
 
381
            escaped=True,
 
382
            )
 
383
        return KnitRevisionStore(versioned_file_store)
 
384
 
 
385
    def _get_text_store(self, transport, control_files):
 
386
        """See RepositoryFormat._get_text_store()."""
 
387
        return self._get_versioned_file_store('knits',
 
388
                                  transport,
 
389
                                  control_files,
 
390
                                  versionedfile_class=knit.KnitVersionedFile,
 
391
                                  versionedfile_kwargs={
 
392
                                      'create_parent_dir':True,
 
393
                                      'delay_create':True,
 
394
                                      'dir_mode':control_files._dir_mode,
 
395
                                  },
 
396
                                  escaped=True)
 
397
 
 
398
    def initialize(self, a_bzrdir, shared=False):
 
399
        """Create a knit format 1 repository.
 
400
 
 
401
        :param a_bzrdir: bzrdir to contain the new repository; must already
 
402
            be initialized.
 
403
        :param shared: If true the repository will be initialized as a shared
 
404
                       repository.
 
405
        """
 
406
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
407
        dirs = ['knits']
 
408
        files = []
 
409
        utf8_files = [('format', self.get_format_string())]
 
410
        
 
411
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
412
        repo_transport = a_bzrdir.get_repository_transport(None)
 
413
        control_files = lockable_files.LockableFiles(repo_transport,
 
414
                                'lock', lockdir.LockDir)
 
415
        control_store = self._get_control_store(repo_transport, control_files)
 
416
        transaction = transactions.WriteTransaction()
 
417
        # trigger a write of the inventory store.
 
418
        control_store.get_weave_or_empty('inventory', transaction)
 
419
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
420
        # the revision id here is irrelevant: it will not be stored, and cannot
 
421
        # already exist.
 
422
        _revision_store.has_revision_id('A', transaction)
 
423
        _revision_store.get_signature_file(transaction)
 
424
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
425
 
 
426
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
427
        """See RepositoryFormat.open().
 
428
        
 
429
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
430
                                    repository at a slightly different url
 
431
                                    than normal. I.e. during 'upgrade'.
 
432
        """
 
433
        if not _found:
 
434
            format = RepositoryFormat.find_format(a_bzrdir)
 
435
            assert format.__class__ ==  self.__class__
 
436
        if _override_transport is not None:
 
437
            repo_transport = _override_transport
 
438
        else:
 
439
            repo_transport = a_bzrdir.get_repository_transport(None)
 
440
        control_files = lockable_files.LockableFiles(repo_transport,
 
441
                                'lock', lockdir.LockDir)
 
442
        text_store = self._get_text_store(repo_transport, control_files)
 
443
        control_store = self._get_control_store(repo_transport, control_files)
 
444
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
445
        return self.repository_class(_format=self,
 
446
                              a_bzrdir=a_bzrdir,
 
447
                              control_files=control_files,
 
448
                              _revision_store=_revision_store,
 
449
                              control_store=control_store,
 
450
                              text_store=text_store,
 
451
                              _commit_builder_class=self._commit_builder_class,
 
452
                              _serializer=self._serializer)
 
453
 
 
454
 
 
455
class RepositoryFormatKnit1(RepositoryFormatKnit):
 
456
    """Bzr repository knit format 1.
 
457
 
 
458
    This repository format has:
 
459
     - knits for file texts and inventory
 
460
     - hash subdirectory based stores.
 
461
     - knits for revisions and signatures
 
462
     - TextStores for revisions and signatures.
 
463
     - a format marker of its own
 
464
     - an optional 'shared-storage' flag
 
465
     - an optional 'no-working-trees' flag
 
466
     - a LockDir lock
 
467
 
 
468
    This format was introduced in bzr 0.8.
 
469
    """
 
470
 
 
471
    repository_class = KnitRepository
 
472
    _commit_builder_class = CommitBuilder
 
473
    _serializer = xml5.serializer_v5
 
474
 
 
475
    def __ne__(self, other):
 
476
        return self.__class__ is not other.__class__
 
477
 
 
478
    def get_format_string(self):
 
479
        """See RepositoryFormat.get_format_string()."""
 
480
        return "Bazaar-NG Knit Repository Format 1"
 
481
 
 
482
    def get_format_description(self):
 
483
        """See RepositoryFormat.get_format_description()."""
 
484
        return "Knit repository format 1"
 
485
 
 
486
    def check_conversion_target(self, target_format):
 
487
        pass
 
488
 
 
489
 
 
490
class RepositoryFormatKnit3(RepositoryFormatKnit):
 
491
    """Bzr repository knit format 3.
 
492
 
 
493
    This repository format has:
 
494
     - knits for file texts and inventory
 
495
     - hash subdirectory based stores.
 
496
     - knits for revisions and signatures
 
497
     - TextStores for revisions and signatures.
 
498
     - a format marker of its own
 
499
     - an optional 'shared-storage' flag
 
500
     - an optional 'no-working-trees' flag
 
501
     - a LockDir lock
 
502
     - support for recording full info about the tree root
 
503
     - support for recording tree-references
 
504
    """
 
505
 
 
506
    repository_class = KnitRepository
 
507
    _commit_builder_class = RootCommitBuilder
 
508
    rich_root_data = True
 
509
    supports_tree_reference = True
 
510
    _serializer = xml7.serializer_v7
 
511
 
 
512
    def _get_matching_bzrdir(self):
 
513
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
514
 
 
515
    def _ignore_setting_bzrdir(self, format):
 
516
        pass
 
517
 
 
518
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
519
 
 
520
    def check_conversion_target(self, target_format):
 
521
        if not target_format.rich_root_data:
 
522
            raise errors.BadConversionTarget(
 
523
                'Does not support rich root data.', target_format)
 
524
        if not getattr(target_format, 'supports_tree_reference', False):
 
525
            raise errors.BadConversionTarget(
 
526
                'Does not support nested trees', target_format)
 
527
            
 
528
    def get_format_string(self):
 
529
        """See RepositoryFormat.get_format_string()."""
 
530
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
 
531
 
 
532
    def get_format_description(self):
 
533
        """See RepositoryFormat.get_format_description()."""
 
534
        return "Knit repository format 3"
 
535
 
 
536
 
 
537
class RepositoryFormatKnit4(RepositoryFormatKnit):
 
538
    """Bzr repository knit format 4.
 
539
 
 
540
    This repository format has everything in format 3, except for
 
541
    tree-references:
 
542
     - knits for file texts and inventory
 
543
     - hash subdirectory based stores.
 
544
     - knits for revisions and signatures
 
545
     - TextStores for revisions and signatures.
 
546
     - a format marker of its own
 
547
     - an optional 'shared-storage' flag
 
548
     - an optional 'no-working-trees' flag
 
549
     - a LockDir lock
 
550
     - support for recording full info about the tree root
 
551
    """
 
552
 
 
553
    repository_class = KnitRepository
 
554
    _commit_builder_class = RootCommitBuilder
 
555
    rich_root_data = True
 
556
    supports_tree_reference = False
 
557
    _serializer = xml6.serializer_v6
 
558
 
 
559
    def _get_matching_bzrdir(self):
 
560
        return bzrdir.format_registry.make_bzrdir('rich-root')
 
561
 
 
562
    def _ignore_setting_bzrdir(self, format):
 
563
        pass
 
564
 
 
565
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
566
 
 
567
    def check_conversion_target(self, target_format):
 
568
        if not target_format.rich_root_data:
 
569
            raise errors.BadConversionTarget(
 
570
                'Does not support rich root data.', target_format)
 
571
 
 
572
    def get_format_string(self):
 
573
        """See RepositoryFormat.get_format_string()."""
 
574
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
 
575
 
 
576
    def get_format_description(self):
 
577
        """See RepositoryFormat.get_format_description()."""
 
578
        return "Knit repository format 4"
 
579
 
 
580
 
 
581
def _get_stream_as_bytes(knit, required_versions):
 
582
    """Generate a serialised data stream.
 
583
 
 
584
    The format is a bencoding of a list.  The first element of the list is a
 
585
    string of the format signature, then each subsequent element is a list
 
586
    corresponding to a record.  Those lists contain:
 
587
 
 
588
      * a version id
 
589
      * a list of options
 
590
      * a list of parents
 
591
      * the bytes
 
592
 
 
593
    :returns: a bencoded list.
 
594
    """
 
595
    knit_stream = knit.get_data_stream(required_versions)
 
596
    format_signature, data_list, callable = knit_stream
 
597
    data = []
 
598
    data.append(format_signature)
 
599
    for version, options, length, parents in data_list:
 
600
        data.append([version, options, parents, callable(length)])
 
601
    return bencode.bencode(data)