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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
19
from bzrlib.lazy_import import lazy_import
20
lazy_import(globals(), """
17
23
from bzrlib import (
30
revision as _mod_revision,
30
39
from bzrlib.decorators import needs_read_lock, needs_write_lock
31
40
from bzrlib.repository import (
33
MetaDirRepositoryFormat,
37
import bzrlib.revision as _mod_revision
38
from bzrlib.store.versioned import VersionedFileStore
39
from bzrlib.trace import mutter, note, warning
40
from bzrlib.util import bencode
43
RepositoryFormatMetaDir,
45
from bzrlib.vf_repository import (
46
InterSameDataRepository,
47
MetaDirVersionedFileRepository,
48
MetaDirVersionedFileRepositoryFormat,
49
VersionedFileCommitBuilder,
50
VersionedFileRootCommitBuilder,
52
from bzrlib import symbol_versioning
43
55
class _KnitParentsProvider(object):
48
60
def __repr__(self):
49
61
return 'KnitParentsProvider(%r)' % self._knit
51
def get_parents(self, revision_ids):
53
for revision_id in revision_ids:
63
def get_parent_map(self, keys):
64
"""See graph.StackedParentsProvider.get_parent_map"""
66
for revision_id in keys:
67
if revision_id is None:
68
raise ValueError('get_parent_map(None) is not valid')
54
69
if revision_id == _mod_revision.NULL_REVISION:
70
parent_map[revision_id] = ()
58
parents = self._knit.get_parents_with_ghosts(revision_id)
74
self._knit.get_parents_with_ghosts(revision_id))
59
75
except errors.RevisionNotPresent:
62
78
if len(parents) == 0:
63
parents = [_mod_revision.NULL_REVISION]
64
parents_list.append(parents)
68
class KnitRepository(MetaDirRepository):
79
parents = (_mod_revision.NULL_REVISION,)
80
parent_map[revision_id] = parents
84
class _KnitsParentsProvider(object):
86
def __init__(self, knit, prefix=()):
87
"""Create a parent provider for string keys mapped to tuple keys."""
92
return 'KnitsParentsProvider(%r)' % self._knit
94
def get_parent_map(self, keys):
95
"""See graph.StackedParentsProvider.get_parent_map"""
96
parent_map = self._knit.get_parent_map(
97
[self._prefix + (key,) for key in keys])
99
for key, parents in parent_map.items():
101
if len(parents) == 0:
102
parents = (_mod_revision.NULL_REVISION,)
104
parents = tuple(parent[-1] for parent in parents)
105
result[revid] = parents
106
for revision_id in keys:
107
if revision_id == _mod_revision.NULL_REVISION:
108
result[revision_id] = ()
112
class KnitRepository(MetaDirVersionedFileRepository):
69
113
"""Knit format repository."""
71
_serializer = xml5.serializer_v5
73
def _warn_if_deprecated(self):
74
# This class isn't deprecated
77
def _inventory_add_lines(self, inv_vf, revid, parents, lines):
78
inv_vf.add_lines_with_ghosts(revid, parents, lines)
115
# These attributes are inherited from the Repository base class. Setting
116
# them to None ensures that if the constructor is changed to not initialize
117
# them, or a subclass fails to call the constructor, that an error will
118
# occur rather than the system working but generating incorrect data.
119
_commit_builder_class = None
122
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
124
super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
125
self._commit_builder_class = _commit_builder_class
126
self._serializer = _serializer
127
self._reconcile_fixes_text_parents = True
81
130
def _all_revision_ids(self):
82
131
"""See Repository.all_revision_ids()."""
83
# Knits get the revision graph from the index of the revision knit, so
84
# it's always possible even if they're on an unlistable transport.
85
return self._revision_store.all_revision_ids(self.get_transaction())
87
def fileid_involved_between_revs(self, from_revid, to_revid):
88
"""Find file_id(s) which are involved in the changes between revisions.
90
This determines the set of revisions which are involved, and then
91
finds all file ids affected by those revisions.
93
from_revid = osutils.safe_revision_id(from_revid)
94
to_revid = osutils.safe_revision_id(to_revid)
95
vf = self._get_revision_vf()
96
from_set = set(vf.get_ancestry(from_revid))
97
to_set = set(vf.get_ancestry(to_revid))
98
changed = to_set.difference(from_set)
99
return self._fileid_involved_by_set(changed)
101
def fileid_involved(self, last_revid=None):
102
"""Find all file_ids modified in the ancestry of last_revid.
104
:param last_revid: If None, last_revision() will be used.
107
changed = set(self.all_revision_ids())
109
changed = set(self.get_ancestry(last_revid))
112
return self._fileid_involved_by_set(changed)
115
def get_ancestry(self, revision_id, topo_sorted=True):
116
"""Return a list of revision-ids integrated by a revision.
118
This is topologically sorted, unless 'topo_sorted' is specified as
121
if _mod_revision.is_null(revision_id):
123
revision_id = osutils.safe_revision_id(revision_id)
124
vf = self._get_revision_vf()
126
return [None] + vf.get_ancestry(revision_id, topo_sorted)
127
except errors.RevisionNotPresent:
128
raise errors.NoSuchRevision(self, revision_id)
132
return [key[0] for key in self.revisions.keys()]
134
def _activate_new_inventory(self):
135
"""Put a replacement inventory.new into use as inventories."""
136
# Copy the content across
138
t.copy('inventory.new.kndx', 'inventory.kndx')
140
t.copy('inventory.new.knit', 'inventory.knit')
141
except errors.NoSuchFile:
142
# empty inventories knit
143
t.delete('inventory.knit')
144
# delete the temp inventory
145
t.delete('inventory.new.kndx')
147
t.delete('inventory.new.knit')
148
except errors.NoSuchFile:
149
# empty inventories knit
151
# Force index reload (sanity check)
152
self.inventories._index._reset_cache()
153
self.inventories.keys()
155
def _backup_inventory(self):
157
t.copy('inventory.kndx', 'inventory.backup.kndx')
158
t.copy('inventory.knit', 'inventory.backup.knit')
160
def _move_file_id(self, from_id, to_id):
161
t = self._transport.clone('knits')
162
from_rel_url = self.texts._index._mapper.map((from_id, None))
163
to_rel_url = self.texts._index._mapper.map((to_id, None))
164
# We expect both files to always exist in this case.
165
for suffix in ('.knit', '.kndx'):
166
t.rename(from_rel_url + suffix, to_rel_url + suffix)
168
def _remove_file_id(self, file_id):
169
t = self._transport.clone('knits')
170
rel_url = self.texts._index._mapper.map((file_id, None))
171
for suffix in ('.kndx', '.knit'):
173
t.delete(rel_url + suffix)
174
except errors.NoSuchFile:
177
def _temp_inventories(self):
178
result = self._format._get_inventories(self._transport, self,
180
# Reconciling when the output has no revisions would result in no
181
# writes - but we want to ensure there is an inventory for
182
# compatibility with older clients that don't lazy-load.
183
result.get_parent_map([('A',)])
131
187
def get_revision(self, revision_id):
133
189
revision_id = osutils.safe_revision_id(revision_id)
134
190
return self.get_revision_reconcile(revision_id)
137
def get_revision_graph(self, revision_id=None):
138
"""Return a dictionary containing the revision graph.
140
:param revision_id: The revision_id to get a graph from. If None, then
141
the entire revision graph is returned. This is a deprecated mode of
142
operation and will be removed in the future.
143
:return: a dictionary of revision_id->revision_parents_list.
145
# special case NULL_REVISION
146
if revision_id == _mod_revision.NULL_REVISION:
148
revision_id = osutils.safe_revision_id(revision_id)
149
a_weave = self._get_revision_vf()
150
if revision_id is None:
151
return a_weave.get_graph()
152
elif revision_id not in a_weave:
153
raise errors.NoSuchRevision(self, revision_id)
155
# add what can be reached from revision_id
156
return a_weave.get_graph([revision_id])
159
def get_revision_graph_with_ghosts(self, revision_ids=None):
160
"""Return a graph of the revisions with ghosts marked as applicable.
162
:param revision_ids: an iterable of revisions to graph or None for all.
163
:return: a Graph object with the graph reachable from revision_ids.
165
result = deprecated_graph.Graph()
166
vf = self._get_revision_vf()
167
versions = set(vf.versions())
169
pending = set(self.all_revision_ids())
172
pending = set(osutils.safe_revision_id(r) for r in revision_ids)
173
# special case NULL_REVISION
174
if _mod_revision.NULL_REVISION in pending:
175
pending.remove(_mod_revision.NULL_REVISION)
176
required = set(pending)
179
revision_id = pending.pop()
180
if not revision_id in versions:
181
if revision_id in required:
182
raise errors.NoSuchRevision(self, revision_id)
184
result.add_ghost(revision_id)
185
# mark it as done so we don't try for it again.
186
done.add(revision_id)
188
parent_ids = vf.get_parents_with_ghosts(revision_id)
189
for parent_id in parent_ids:
190
# is this queued or done ?
191
if (parent_id not in pending and
192
parent_id not in done):
194
pending.add(parent_id)
195
result.add_node(revision_id, parent_ids)
196
done.add(revision_id)
199
def _get_revision_vf(self):
200
""":return: a versioned file containing the revisions."""
201
vf = self._revision_store.get_revision_file(self.get_transaction())
204
def _get_history_vf(self):
205
"""Get a versionedfile whose history graph reflects all revisions.
207
For knit repositories, this is the revision knit.
209
return self._get_revision_vf()
192
def _refresh_data(self):
193
if not self.is_locked():
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()
203
self.control_files._set_read_transaction()
211
205
@needs_write_lock
212
206
def reconcile(self, other=None, thorough=False):
215
209
reconciler = KnitReconciler(self, thorough=thorough)
216
210
reconciler.reconcile()
217
211
return reconciler
219
def revision_parents(self, revision_id):
220
revision_id = osutils.safe_revision_id(revision_id)
221
return self._get_revision_vf().get_parents(revision_id)
223
213
def _make_parents_provider(self):
224
return _KnitParentsProvider(self._get_revision_vf())
227
class KnitRepository3(KnitRepository):
229
def __init__(self, _format, a_bzrdir, control_files, _revision_store,
230
control_store, text_store):
231
KnitRepository.__init__(self, _format, a_bzrdir, control_files,
232
_revision_store, control_store, text_store)
233
self._serializer = xml7.serializer_v7
235
def deserialise_inventory(self, revision_id, xml):
236
"""Transform the xml into an inventory object.
238
:param revision_id: The expected revision id of the inventory.
239
:param xml: A serialised inventory.
241
result = self._serializer.read_inventory_from_string(xml)
242
assert result.root.revision is not None
245
def serialise_inventory(self, inv):
246
"""Transform the inventory object into XML text.
248
:param revision_id: The expected revision id of the inventory.
249
:param xml: A serialised inventory.
251
assert inv.revision_id is not None
252
assert inv.root.revision is not None
253
return KnitRepository.serialise_inventory(self, inv)
255
def get_commit_builder(self, branch, parents, config, timestamp=None,
256
timezone=None, committer=None, revprops=None,
258
"""Obtain a CommitBuilder for this repository.
260
:param branch: Branch to commit to.
261
:param parents: Revision ids of the parents of the new revision.
262
:param config: Configuration to use.
263
:param timestamp: Optional timestamp recorded for commit.
264
:param timezone: Optional timezone for timestamp.
265
:param committer: Optional committer to set for commit.
266
:param revprops: Optional dictionary of revision properties.
267
:param revision_id: Optional revision id.
269
revision_id = osutils.safe_revision_id(revision_id)
270
result = RootCommitBuilder(self, parents, config, timestamp, timezone,
271
committer, revprops, revision_id)
272
self.start_write_group()
276
class RepositoryFormatKnit(MetaDirRepositoryFormat):
277
"""Bzr repository knit format (generalized).
214
return _KnitsParentsProvider(self.revisions)
217
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
218
"""Bzr repository knit format (generalized).
279
220
This repository format has:
280
221
- knits for file texts and inventory
290
def _get_control_store(self, repo_transport, control_files):
291
"""Return the control store for this repository."""
292
return VersionedFileStore(
295
file_mode=control_files._file_mode,
296
versionedfile_class=knit.KnitVersionedFile,
297
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
300
def _get_revision_store(self, repo_transport, control_files):
301
"""See RepositoryFormat._get_revision_store()."""
302
from bzrlib.store.revision.knit import KnitRevisionStore
303
versioned_file_store = VersionedFileStore(
305
file_mode=control_files._file_mode,
308
versionedfile_class=knit.KnitVersionedFile,
309
versionedfile_kwargs={'delta':False,
310
'factory':knit.KnitPlainFactory(),
314
return KnitRevisionStore(versioned_file_store)
316
def _get_text_store(self, transport, control_files):
317
"""See RepositoryFormat._get_text_store()."""
318
return self._get_versioned_file_store('knits',
321
versionedfile_class=knit.KnitVersionedFile,
322
versionedfile_kwargs={
323
'create_parent_dir':True,
325
'dir_mode':control_files._dir_mode,
231
# Set this attribute in derived classes to control the repository class
232
# created by open and initialize.
233
repository_class = None
234
# Set this attribute in derived classes to control the
235
# _commit_builder_class that the repository objects will have passed to
237
_commit_builder_class = None
238
# Set this attribute in derived clases to control the _serializer that the
239
# repository objects will have passed to their constructor.
241
def _serializer(self):
242
return xml5.serializer_v5
243
# Knit based repositories handle ghosts reasonably well.
244
supports_ghosts = True
245
# External lookups are not supported in this format.
246
supports_external_lookups = False
248
supports_chks = False
249
_fetch_order = 'topological'
250
_fetch_uses_deltas = True
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
257
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)
264
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,
272
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,
280
def _get_texts(self, repo_transport, repo):
281
mapper = versionedfile.HashEscapedPrefixMapper()
282
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,
329
289
def initialize(self, a_bzrdir, shared=False):
330
290
"""Create a knit format 1 repository.
334
294
:param shared: If true the repository will be initialized as a shared
337
mutter('creating repository in %s.', a_bzrdir.transport.base)
338
dirs = ['revision-store', 'knits']
297
trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
340
300
utf8_files = [('format', self.get_format_string())]
342
302
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
343
303
repo_transport = a_bzrdir.get_repository_transport(None)
344
304
control_files = lockable_files.LockableFiles(repo_transport,
345
305
'lock', lockdir.LockDir)
346
control_store = self._get_control_store(repo_transport, control_files)
347
306
transaction = transactions.WriteTransaction()
348
# trigger a write of the inventory store.
349
control_store.get_weave_or_empty('inventory', transaction)
350
_revision_store = self._get_revision_store(repo_transport, control_files)
307
result = self.open(a_bzrdir=a_bzrdir, _found=True)
351
309
# the revision id here is irrelevant: it will not be stored, and cannot
353
_revision_store.has_revision_id('A', transaction)
354
_revision_store.get_signature_file(transaction)
355
return self.open(a_bzrdir=a_bzrdir, _found=True)
310
# already exist, we do this to create files on disk for older clients.
311
result.inventories.get_parent_map([('A',)])
312
result.revisions.get_parent_map([('A',)])
313
result.signatures.get_parent_map([('A',)])
315
self._run_post_repo_init_hooks(result, a_bzrdir, shared)
357
318
def open(self, a_bzrdir, _found=False, _override_transport=None):
358
319
"""See RepositoryFormat.open().
360
321
:param _override_transport: INTERNAL USE ONLY. Allows opening the
361
322
repository at a slightly different url
362
323
than normal. I.e. during 'upgrade'.
365
format = RepositoryFormat.find_format(a_bzrdir)
366
assert format.__class__ == self.__class__
326
format = RepositoryFormatMetaDir.find_format(a_bzrdir)
367
327
if _override_transport is not None:
368
328
repo_transport = _override_transport
370
330
repo_transport = a_bzrdir.get_repository_transport(None)
371
331
control_files = lockable_files.LockableFiles(repo_transport,
372
332
'lock', lockdir.LockDir)
373
text_store = self._get_text_store(repo_transport, control_files)
374
control_store = self._get_control_store(repo_transport, control_files)
375
_revision_store = self._get_revision_store(repo_transport, control_files)
376
return KnitRepository(_format=self,
333
repo = self.repository_class(_format=self,
377
334
a_bzrdir=a_bzrdir,
378
335
control_files=control_files,
379
_revision_store=_revision_store,
380
control_store=control_store,
381
text_store=text_store)
336
_commit_builder_class=self._commit_builder_class,
337
_serializer=self._serializer)
338
repo.revisions = self._get_revisions(repo_transport, repo)
339
repo.signatures = self._get_signatures(repo_transport, repo)
340
repo.inventories = self._get_inventories(repo_transport, repo)
341
repo.texts = self._get_texts(repo_transport, repo)
342
repo.chk_bytes = None
343
repo._transport = repo_transport
384
347
class RepositoryFormatKnit1(RepositoryFormatKnit):
428
395
- support for recording tree-references
431
repository_class = KnitRepository3
398
repository_class = KnitRepository
399
_commit_builder_class = VersionedFileRootCommitBuilder
432
400
rich_root_data = True
433
402
supports_tree_reference = True
404
def _serializer(self):
405
return xml7.serializer_v7
435
407
def _get_matching_bzrdir(self):
436
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
408
return controldir.format_registry.make_bzrdir('dirstate-with-subtree')
438
410
def _ignore_setting_bzrdir(self, format):
441
413
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
443
def check_conversion_target(self, target_format):
444
if not target_format.rich_root_data:
445
raise errors.BadConversionTarget(
446
'Does not support rich root data.', target_format)
447
if not getattr(target_format, 'supports_tree_reference', False):
448
raise errors.BadConversionTarget(
449
'Does not support nested trees', target_format)
451
def get_format_string(self):
416
def get_format_string(cls):
452
417
"""See RepositoryFormat.get_format_string()."""
453
418
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
456
421
"""See RepositoryFormat.get_format_description()."""
457
422
return "Knit repository format 3"
459
def open(self, a_bzrdir, _found=False, _override_transport=None):
460
"""See RepositoryFormat.open().
462
:param _override_transport: INTERNAL USE ONLY. Allows opening the
463
repository at a slightly different url
464
than normal. I.e. during 'upgrade'.
425
class RepositoryFormatKnit4(RepositoryFormatKnit):
426
"""Bzr repository knit format 4.
428
This repository format has everything in format 3, except for
430
- knits for file texts and inventory
431
- hash subdirectory based stores.
432
- knits for revisions and signatures
433
- TextStores for revisions and signatures.
434
- a format marker of its own
435
- an optional 'shared-storage' flag
436
- an optional 'no-working-trees' flag
438
- support for recording full info about the tree root
441
repository_class = KnitRepository
442
_commit_builder_class = VersionedFileRootCommitBuilder
443
rich_root_data = True
444
supports_tree_reference = False
446
def _serializer(self):
447
return xml6.serializer_v6
449
def _get_matching_bzrdir(self):
450
return controldir.format_registry.make_bzrdir('rich-root')
452
def _ignore_setting_bzrdir(self, format):
455
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
458
def get_format_string(cls):
459
"""See RepositoryFormat.get_format_string()."""
460
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
462
def get_format_description(self):
463
"""See RepositoryFormat.get_format_description()."""
464
return "Knit repository format 4"
467
class InterKnitRepo(InterSameDataRepository):
468
"""Optimised code paths between Knit based repositories."""
471
def _get_repo_format_to_test(self):
472
return RepositoryFormatKnit1()
475
def is_compatible(source, target):
476
"""Be compatible with known Knit formats.
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
467
format = RepositoryFormat.find_format(a_bzrdir)
468
assert format.__class__ == self.__class__
469
if _override_transport is not None:
470
repo_transport = _override_transport
483
are_knits = (isinstance(source._format, RepositoryFormatKnit) and
484
isinstance(target._format, RepositoryFormatKnit))
485
except AttributeError:
487
return are_knits and InterRepository._same_model(source, target)
490
def search_missing_revision_ids(self,
491
find_ghosts=True, revision_ids=None, if_present_ids=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
472
repo_transport = a_bzrdir.get_repository_transport(None)
473
control_files = lockable_files.LockableFiles(repo_transport, 'lock',
475
text_store = self._get_text_store(repo_transport, control_files)
476
control_store = self._get_control_store(repo_transport, control_files)
477
_revision_store = self._get_revision_store(repo_transport, control_files)
478
return self.repository_class(_format=self,
480
control_files=control_files,
481
_revision_store=_revision_store,
482
control_store=control_store,
483
text_store=text_store)
486
def _get_stream_as_bytes(knit, required_versions):
487
"""Generate a serialised data stream.
489
The format is a bencoding of a list. The first element of the list is a
490
string of the format signature, then each subsequent element is a list
491
corresponding to a record. Those lists contain:
498
:returns: a bencoded list.
500
knit_stream = knit.get_data_stream(required_versions)
501
format_signature, data_list, callable = knit_stream
503
data.append(format_signature)
504
for version, options, length, parents in data_list:
505
data.append([version, options, parents, callable(length)])
506
return bencode.bencode(data)
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.
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)
522
InterRepository.register_optimiser(InterKnitRepo)
added
removed
bzrlib/repofmt/knitrepo.py
