/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

 * ``InterRepository.missing_revision_ids`` is now deprecated in favour of
   ``InterRepository.search_missing_revision_ids`` which returns a 
   ``bzrlib.graph.SearchResult`` suitable for making requests from the smart
   server. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/knitrepo.py
 
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
    @needs_read_lock
 
161
    def get_data_stream(self, revision_ids):
 
162
        """See Repository.get_data_stream."""
 
163
        item_keys = self.item_keys_introduced_by(revision_ids)
 
164
        for knit_kind, file_id, versions in item_keys:
 
165
            name = (knit_kind,)
 
166
            if knit_kind == 'file':
 
167
                name = ('file', file_id)
 
168
                knit = self.weave_store.get_weave_or_empty(
 
169
                    file_id, self.get_transaction())
 
170
            elif knit_kind == 'inventory':
 
171
                knit = self.get_inventory_weave()
 
172
            elif knit_kind == 'revisions':
 
173
                knit = self._revision_store.get_revision_file(
 
174
                    self.get_transaction())
 
175
            elif knit_kind == 'signatures':
 
176
                knit = self._revision_store.get_signature_file(
 
177
                    self.get_transaction())
 
178
            else:
 
179
                raise AssertionError('Unknown knit kind %r' % (knit_kind,))
 
180
            yield name, _get_stream_as_bytes(knit, versions)
 
181
 
 
182
    @needs_read_lock
 
183
    def get_revision(self, revision_id):
 
184
        """Return the Revision object for a named revision"""
 
185
        revision_id = osutils.safe_revision_id(revision_id)
 
186
        return self.get_revision_reconcile(revision_id)
 
187
 
 
188
    @needs_read_lock
 
189
    def get_revision_graph(self, revision_id=None):
 
190
        """Return a dictionary containing the revision graph.
 
191
 
 
192
        :param revision_id: The revision_id to get a graph from. If None, then
 
193
        the entire revision graph is returned. This is a deprecated mode of
 
194
        operation and will be removed in the future.
 
195
        :return: a dictionary of revision_id->revision_parents_list.
 
196
        """
 
197
        if 'evil' in debug.debug_flags:
 
198
            mutter_callsite(3,
 
199
                "get_revision_graph scales with size of history.")
 
200
        # special case NULL_REVISION
 
201
        if revision_id == _mod_revision.NULL_REVISION:
 
202
            return {}
 
203
        a_weave = self._get_revision_vf()
 
204
        if revision_id is None:
 
205
            return a_weave.get_graph()
 
206
        if revision_id not in a_weave:
 
207
            raise errors.NoSuchRevision(self, revision_id)
 
208
        else:
 
209
            # add what can be reached from revision_id
 
210
            return a_weave.get_graph([revision_id])
 
211
 
 
212
    @needs_read_lock
 
213
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
214
        """Return a graph of the revisions with ghosts marked as applicable.
 
215
 
 
216
        :param revision_ids: an iterable of revisions to graph or None for all.
 
217
        :return: a Graph object with the graph reachable from revision_ids.
 
218
        """
 
219
        if 'evil' in debug.debug_flags:
 
220
            mutter_callsite(3,
 
221
                "get_revision_graph_with_ghosts scales with size of history.")
 
222
        result = deprecated_graph.Graph()
 
223
        vf = self._get_revision_vf()
 
224
        versions = set(vf.versions())
 
225
        if not revision_ids:
 
226
            pending = set(self.all_revision_ids())
 
227
            required = set([])
 
228
        else:
 
229
            pending = set(revision_ids)
 
230
            # special case NULL_REVISION
 
231
            if _mod_revision.NULL_REVISION in pending:
 
232
                pending.remove(_mod_revision.NULL_REVISION)
 
233
            required = set(pending)
 
234
        done = set([])
 
235
        while len(pending):
 
236
            revision_id = pending.pop()
 
237
            if not revision_id in versions:
 
238
                if revision_id in required:
 
239
                    raise errors.NoSuchRevision(self, revision_id)
 
240
                # a ghost
 
241
                result.add_ghost(revision_id)
 
242
                # mark it as done so we don't try for it again.
 
243
                done.add(revision_id)
 
244
                continue
 
245
            parent_ids = vf.get_parents_with_ghosts(revision_id)
 
246
            for parent_id in parent_ids:
 
247
                # is this queued or done ?
 
248
                if (parent_id not in pending and
 
249
                    parent_id not in done):
 
250
                    # no, queue it.
 
251
                    pending.add(parent_id)
 
252
            result.add_node(revision_id, parent_ids)
 
253
            done.add(revision_id)
 
254
        return result
 
255
 
 
256
    def _get_revision_vf(self):
 
257
        """:return: a versioned file containing the revisions."""
 
258
        vf = self._revision_store.get_revision_file(self.get_transaction())
 
259
        return vf
 
260
 
 
261
    def _get_history_vf(self):
 
262
        """Get a versionedfile whose history graph reflects all revisions.
 
263
 
 
264
        For knit repositories, this is the revision knit.
 
265
        """
 
266
        return self._get_revision_vf()
 
267
 
 
268
    def has_revisions(self, revision_ids):
 
269
        """See Repository.has_revisions()."""
 
270
        result = set()
 
271
        transaction = self.get_transaction()
 
272
        for revision_id in revision_ids:
 
273
            if self._revision_store.has_revision_id(revision_id, transaction):
 
274
                result.add(revision_id)
 
275
        return result
 
276
 
 
277
    @needs_write_lock
 
278
    def reconcile(self, other=None, thorough=False):
 
279
        """Reconcile this repository."""
 
280
        from bzrlib.reconcile import KnitReconciler
 
281
        reconciler = KnitReconciler(self, thorough=thorough)
 
282
        reconciler.reconcile()
 
283
        return reconciler
 
284
    
 
285
    def revision_parents(self, revision_id):
 
286
        return self._get_revision_vf().get_parents(revision_id)
 
287
 
 
288
    def _make_parents_provider(self):
 
289
        return _KnitParentsProvider(self._get_revision_vf())
 
290
 
 
291
    def _find_inconsistent_revision_parents(self):
 
292
        """Find revisions with different parent lists in the revision object
 
293
        and in the index graph.
 
294
 
 
295
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
 
296
            parents-in-revision).
 
297
        """
 
298
        assert self.is_locked()
 
299
        vf = self._get_revision_vf()
 
300
        for index_version in vf.versions():
 
301
            parents_according_to_index = tuple(vf.get_parents_with_ghosts(
 
302
                index_version))
 
303
            revision = self.get_revision(index_version)
 
304
            parents_according_to_revision = tuple(revision.parent_ids)
 
305
            if parents_according_to_index != parents_according_to_revision:
 
306
                yield (index_version, parents_according_to_index,
 
307
                    parents_according_to_revision)
 
308
 
 
309
    def _check_for_inconsistent_revision_parents(self):
 
310
        inconsistencies = list(self._find_inconsistent_revision_parents())
 
311
        if inconsistencies:
 
312
            raise errors.BzrCheckError(
 
313
                "Revision knit has inconsistent parents.")
 
314
 
 
315
    def revision_graph_can_have_wrong_parents(self):
 
316
        # The revision.kndx could potentially claim a revision has a different
 
317
        # parent to the revision text.
 
318
        return True
 
319
 
 
320
 
 
321
class RepositoryFormatKnit(MetaDirRepositoryFormat):
 
322
    """Bzr repository knit format (generalized). 
 
323
 
 
324
    This repository format has:
 
325
     - knits for file texts and inventory
 
326
     - hash subdirectory based stores.
 
327
     - knits for revisions and signatures
 
328
     - TextStores for revisions and signatures.
 
329
     - a format marker of its own
 
330
     - an optional 'shared-storage' flag
 
331
     - an optional 'no-working-trees' flag
 
332
     - a LockDir lock
 
333
    """
 
334
 
 
335
    # Set this attribute in derived classes to control the repository class
 
336
    # created by open and initialize.
 
337
    repository_class = None
 
338
    # Set this attribute in derived classes to control the
 
339
    # _commit_builder_class that the repository objects will have passed to
 
340
    # their constructor.
 
341
    _commit_builder_class = None
 
342
    # Set this attribute in derived clases to control the _serializer that the
 
343
    # repository objects will have passed to their constructor.
 
344
    _serializer = xml5.serializer_v5
 
345
    # Knit based repositories handle ghosts reasonably well.
 
346
    supports_ghosts = True
 
347
 
 
348
    def _get_control_store(self, repo_transport, control_files):
 
349
        """Return the control store for this repository."""
 
350
        return VersionedFileStore(
 
351
            repo_transport,
 
352
            prefixed=False,
 
353
            file_mode=control_files._file_mode,
 
354
            versionedfile_class=knit.KnitVersionedFile,
 
355
            versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
 
356
            )
 
357
 
 
358
    def _get_revision_store(self, repo_transport, control_files):
 
359
        """See RepositoryFormat._get_revision_store()."""
 
360
        versioned_file_store = VersionedFileStore(
 
361
            repo_transport,
 
362
            file_mode=control_files._file_mode,
 
363
            prefixed=False,
 
364
            precious=True,
 
365
            versionedfile_class=knit.KnitVersionedFile,
 
366
            versionedfile_kwargs={'delta':False,
 
367
                                  'factory':knit.KnitPlainFactory(),
 
368
                                 },
 
369
            escaped=True,
 
370
            )
 
371
        return KnitRevisionStore(versioned_file_store)
 
372
 
 
373
    def _get_text_store(self, transport, control_files):
 
374
        """See RepositoryFormat._get_text_store()."""
 
375
        return self._get_versioned_file_store('knits',
 
376
                                  transport,
 
377
                                  control_files,
 
378
                                  versionedfile_class=knit.KnitVersionedFile,
 
379
                                  versionedfile_kwargs={
 
380
                                      'create_parent_dir':True,
 
381
                                      'delay_create':True,
 
382
                                      'dir_mode':control_files._dir_mode,
 
383
                                  },
 
384
                                  escaped=True)
 
385
 
 
386
    def initialize(self, a_bzrdir, shared=False):
 
387
        """Create a knit format 1 repository.
 
388
 
 
389
        :param a_bzrdir: bzrdir to contain the new repository; must already
 
390
            be initialized.
 
391
        :param shared: If true the repository will be initialized as a shared
 
392
                       repository.
 
393
        """
 
394
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
395
        dirs = ['knits']
 
396
        files = []
 
397
        utf8_files = [('format', self.get_format_string())]
 
398
        
 
399
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
400
        repo_transport = a_bzrdir.get_repository_transport(None)
 
401
        control_files = lockable_files.LockableFiles(repo_transport,
 
402
                                'lock', lockdir.LockDir)
 
403
        control_store = self._get_control_store(repo_transport, control_files)
 
404
        transaction = transactions.WriteTransaction()
 
405
        # trigger a write of the inventory store.
 
406
        control_store.get_weave_or_empty('inventory', transaction)
 
407
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
408
        # the revision id here is irrelevant: it will not be stored, and cannot
 
409
        # already exist.
 
410
        _revision_store.has_revision_id('A', transaction)
 
411
        _revision_store.get_signature_file(transaction)
 
412
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
413
 
 
414
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
415
        """See RepositoryFormat.open().
 
416
        
 
417
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
418
                                    repository at a slightly different url
 
419
                                    than normal. I.e. during 'upgrade'.
 
420
        """
 
421
        if not _found:
 
422
            format = RepositoryFormat.find_format(a_bzrdir)
 
423
            assert format.__class__ ==  self.__class__
 
424
        if _override_transport is not None:
 
425
            repo_transport = _override_transport
 
426
        else:
 
427
            repo_transport = a_bzrdir.get_repository_transport(None)
 
428
        control_files = lockable_files.LockableFiles(repo_transport,
 
429
                                'lock', lockdir.LockDir)
 
430
        text_store = self._get_text_store(repo_transport, control_files)
 
431
        control_store = self._get_control_store(repo_transport, control_files)
 
432
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
433
        return self.repository_class(_format=self,
 
434
                              a_bzrdir=a_bzrdir,
 
435
                              control_files=control_files,
 
436
                              _revision_store=_revision_store,
 
437
                              control_store=control_store,
 
438
                              text_store=text_store,
 
439
                              _commit_builder_class=self._commit_builder_class,
 
440
                              _serializer=self._serializer)
 
441
 
 
442
 
 
443
class RepositoryFormatKnit1(RepositoryFormatKnit):
 
444
    """Bzr repository knit format 1.
 
445
 
 
446
    This repository format has:
 
447
     - knits for file texts and inventory
 
448
     - hash subdirectory based stores.
 
449
     - knits for revisions and signatures
 
450
     - TextStores for revisions and signatures.
 
451
     - a format marker of its own
 
452
     - an optional 'shared-storage' flag
 
453
     - an optional 'no-working-trees' flag
 
454
     - a LockDir lock
 
455
 
 
456
    This format was introduced in bzr 0.8.
 
457
    """
 
458
 
 
459
    repository_class = KnitRepository
 
460
    _commit_builder_class = CommitBuilder
 
461
    _serializer = xml5.serializer_v5
 
462
 
 
463
    def __ne__(self, other):
 
464
        return self.__class__ is not other.__class__
 
465
 
 
466
    def get_format_string(self):
 
467
        """See RepositoryFormat.get_format_string()."""
 
468
        return "Bazaar-NG Knit Repository Format 1"
 
469
 
 
470
    def get_format_description(self):
 
471
        """See RepositoryFormat.get_format_description()."""
 
472
        return "Knit repository format 1"
 
473
 
 
474
    def check_conversion_target(self, target_format):
 
475
        pass
 
476
 
 
477
 
 
478
class RepositoryFormatKnit3(RepositoryFormatKnit):
 
479
    """Bzr repository knit format 3.
 
480
 
 
481
    This repository format has:
 
482
     - knits for file texts and inventory
 
483
     - hash subdirectory based stores.
 
484
     - knits for revisions and signatures
 
485
     - TextStores for revisions and signatures.
 
486
     - a format marker of its own
 
487
     - an optional 'shared-storage' flag
 
488
     - an optional 'no-working-trees' flag
 
489
     - a LockDir lock
 
490
     - support for recording full info about the tree root
 
491
     - support for recording tree-references
 
492
    """
 
493
 
 
494
    repository_class = KnitRepository
 
495
    _commit_builder_class = RootCommitBuilder
 
496
    rich_root_data = True
 
497
    supports_tree_reference = True
 
498
    _serializer = xml7.serializer_v7
 
499
 
 
500
    def _get_matching_bzrdir(self):
 
501
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
502
 
 
503
    def _ignore_setting_bzrdir(self, format):
 
504
        pass
 
505
 
 
506
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
507
 
 
508
    def check_conversion_target(self, target_format):
 
509
        if not target_format.rich_root_data:
 
510
            raise errors.BadConversionTarget(
 
511
                'Does not support rich root data.', target_format)
 
512
        if not getattr(target_format, 'supports_tree_reference', False):
 
513
            raise errors.BadConversionTarget(
 
514
                'Does not support nested trees', target_format)
 
515
            
 
516
    def get_format_string(self):
 
517
        """See RepositoryFormat.get_format_string()."""
 
518
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
 
519
 
 
520
    def get_format_description(self):
 
521
        """See RepositoryFormat.get_format_description()."""
 
522
        return "Knit repository format 3"
 
523
 
 
524
 
 
525
class RepositoryFormatKnit4(RepositoryFormatKnit):
 
526
    """Bzr repository knit format 4.
 
527
 
 
528
    This repository format has everything in format 3, except for
 
529
    tree-references:
 
530
     - knits for file texts and inventory
 
531
     - hash subdirectory based stores.
 
532
     - knits for revisions and signatures
 
533
     - TextStores for revisions and signatures.
 
534
     - a format marker of its own
 
535
     - an optional 'shared-storage' flag
 
536
     - an optional 'no-working-trees' flag
 
537
     - a LockDir lock
 
538
     - support for recording full info about the tree root
 
539
    """
 
540
 
 
541
    repository_class = KnitRepository
 
542
    _commit_builder_class = RootCommitBuilder
 
543
    rich_root_data = True
 
544
    supports_tree_reference = False
 
545
    _serializer = xml6.serializer_v6
 
546
 
 
547
    def _get_matching_bzrdir(self):
 
548
        return bzrdir.format_registry.make_bzrdir('rich-root')
 
549
 
 
550
    def _ignore_setting_bzrdir(self, format):
 
551
        pass
 
552
 
 
553
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
554
 
 
555
    def check_conversion_target(self, target_format):
 
556
        if not target_format.rich_root_data:
 
557
            raise errors.BadConversionTarget(
 
558
                'Does not support rich root data.', target_format)
 
559
 
 
560
    def get_format_string(self):
 
561
        """See RepositoryFormat.get_format_string()."""
 
562
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
 
563
 
 
564
    def get_format_description(self):
 
565
        """See RepositoryFormat.get_format_description()."""
 
566
        return "Knit repository format 4"
 
567
 
 
568
 
 
569
def _get_stream_as_bytes(knit, required_versions):
 
570
    """Generate a serialised data stream.
 
571
 
 
572
    The format is a bencoding of a list.  The first element of the list is a
 
573
    string of the format signature, then each subsequent element is a list
 
574
    corresponding to a record.  Those lists contain:
 
575
 
 
576
      * a version id
 
577
      * a list of options
 
578
      * a list of parents
 
579
      * the bytes
 
580
 
 
581
    :returns: a bencoded list.
 
582
    """
 
583
    knit_stream = knit.get_data_stream(required_versions)
 
584
    format_signature, data_list, callable = knit_stream
 
585
    data = []
 
586
    data.append(format_signature)
 
587
    for version, options, length, parents in data_list:
 
588
        data.append([version, options, parents, callable(length)])
 
589
    return bencode.bencode(data)