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
17
from __future__ import absolute_import
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
17
from bzrlib.lazy_import import lazy_import
20
18
lazy_import(globals(), """
22
from bzrlib.store import revision
23
from bzrlib.store.revision.knit import KnitRevisionStore
30
revision as _mod_revision,
39
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
from bzrlib.knit import KnitVersionedFiles, _KndxIndex, _KnitKeyAccess
40
40
from bzrlib.repository import (
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
MetaDirRepositoryFormat,
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
55
54
class _KnitParentsProvider(object):
183
190
result.get_parent_map([('A',)])
193
def fileid_involved_between_revs(self, from_revid, to_revid):
194
"""Find file_id(s) which are involved in the changes between revisions.
196
This determines the set of revisions which are involved, and then
197
finds all file ids affected by those revisions.
199
vf = self._get_revision_vf()
200
from_set = set(vf.get_ancestry(from_revid))
201
to_set = set(vf.get_ancestry(to_revid))
202
changed = to_set.difference(from_set)
203
return self._fileid_involved_by_set(changed)
205
def fileid_involved(self, last_revid=None):
206
"""Find all file_ids modified in the ancestry of last_revid.
208
:param last_revid: If None, last_revision() will be used.
211
changed = set(self.all_revision_ids())
213
changed = set(self.get_ancestry(last_revid))
216
return self._fileid_involved_by_set(changed)
187
219
def get_revision(self, revision_id):
188
220
"""Return the Revision object for a named revision"""
189
221
revision_id = osutils.safe_revision_id(revision_id)
190
222
return self.get_revision_reconcile(revision_id)
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()
205
224
@needs_write_lock
206
225
def reconcile(self, other=None, thorough=False):
207
226
"""Reconcile this repository."""
209
228
reconciler = KnitReconciler(self, thorough=thorough)
210
229
reconciler.reconcile()
211
230
return reconciler
213
232
def _make_parents_provider(self):
214
233
return _KnitsParentsProvider(self.revisions)
217
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
218
"""Bzr repository knit format (generalized).
235
def _find_inconsistent_revision_parents(self):
236
"""Find revisions with different parent lists in the revision object
237
and in the index graph.
239
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
240
parents-in-revision).
242
if not self.is_locked():
243
raise AssertionError()
245
for index_version in vf.keys():
246
parent_map = vf.get_parent_map([index_version])
247
parents_according_to_index = tuple(parent[-1] for parent in
248
parent_map[index_version])
249
revision = self.get_revision(index_version[-1])
250
parents_according_to_revision = tuple(revision.parent_ids)
251
if parents_according_to_index != parents_according_to_revision:
252
yield (index_version[-1], parents_according_to_index,
253
parents_according_to_revision)
255
def _check_for_inconsistent_revision_parents(self):
256
inconsistencies = list(self._find_inconsistent_revision_parents())
258
raise errors.BzrCheckError(
259
"Revision knit has inconsistent parents.")
261
def revision_graph_can_have_wrong_parents(self):
262
# The revision.kndx could potentially claim a revision has a different
263
# parent to the revision text.
267
class RepositoryFormatKnit(MetaDirRepositoryFormat):
268
"""Bzr repository knit format (generalized).
220
270
This repository format has:
221
271
- knits for file texts and inventory
237
287
_commit_builder_class = None
238
288
# Set this attribute in derived clases to control the _serializer that the
239
289
# repository objects will have passed to their constructor.
241
def _serializer(self):
242
return xml5.serializer_v5
290
_serializer = xml5.serializer_v5
243
291
# Knit based repositories handle ghosts reasonably well.
244
292
supports_ghosts = True
245
293
# External lookups are not supported in this format.
246
294
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
296
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)
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)
264
303
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,
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,
272
311
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,
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,
280
319
def _get_texts(self, repo_transport, repo):
281
mapper = versionedfile.HashEscapedPrefixMapper()
320
mapper = HashEscapedPrefixMapper()
282
321
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,
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,
289
328
def initialize(self, a_bzrdir, shared=False):
398
435
repository_class = KnitRepository
399
_commit_builder_class = VersionedFileRootCommitBuilder
436
_commit_builder_class = RootCommitBuilder
400
437
rich_root_data = True
402
438
supports_tree_reference = True
404
def _serializer(self):
405
return xml7.serializer_v7
439
_serializer = xml7.serializer_v7
407
441
def _get_matching_bzrdir(self):
408
return controldir.format_registry.make_bzrdir('dirstate-with-subtree')
442
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
410
444
def _ignore_setting_bzrdir(self, format):
413
447
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
416
def get_format_string(cls):
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)
457
def get_format_string(self):
417
458
"""See RepositoryFormat.get_format_string()."""
418
459
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
441
482
repository_class = KnitRepository
442
_commit_builder_class = VersionedFileRootCommitBuilder
483
_commit_builder_class = RootCommitBuilder
443
484
rich_root_data = True
444
485
supports_tree_reference = False
446
def _serializer(self):
447
return xml6.serializer_v6
486
_serializer = xml6.serializer_v6
449
488
def _get_matching_bzrdir(self):
450
return controldir.format_registry.make_bzrdir('rich-root')
489
return bzrdir.format_registry.make_bzrdir('rich-root')
452
491
def _ignore_setting_bzrdir(self, format):
455
494
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
458
def get_format_string(cls):
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)
501
def get_format_string(self):
459
502
"""See RepositoryFormat.get_format_string()."""
460
503
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
462
505
def get_format_description(self):
463
506
"""See RepositoryFormat.get_format_description()."""
464
507
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
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
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)