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
40
39
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
42
MetaDirRepositoryFormat,
46
import bzrlib.revision as _mod_revision
47
from bzrlib.store.versioned import VersionedFileStore
48
from bzrlib.trace import mutter, mutter_callsite
49
from bzrlib.util import bencode
55
52
class _KnitParentsProvider(object):
60
57
def __repr__(self):
61
58
return 'KnitParentsProvider(%r)' % self._knit
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')
60
def get_parents(self, revision_ids):
62
for revision_id in revision_ids:
69
63
if revision_id == _mod_revision.NULL_REVISION:
70
parent_map[revision_id] = ()
74
self._knit.get_parents_with_ghosts(revision_id))
67
parents = self._knit.get_parents_with_ghosts(revision_id)
75
68
except errors.RevisionNotPresent:
78
71
if len(parents) == 0:
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):
72
parents = [_mod_revision.NULL_REVISION]
73
parents_list.append(parents)
77
class KnitRepository(MetaDirRepository):
113
78
"""Knit format repository."""
115
80
# These attributes are inherited from the Repository base class. Setting
119
84
_commit_builder_class = None
120
85
_serializer = None
122
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
124
super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
87
def __init__(self, _format, a_bzrdir, control_files, _revision_store,
88
control_store, text_store, _commit_builder_class, _serializer):
89
MetaDirRepository.__init__(self, _format, a_bzrdir, control_files,
90
_revision_store, control_store, text_store)
125
91
self._commit_builder_class = _commit_builder_class
126
92
self._serializer = _serializer
127
93
self._reconcile_fixes_text_parents = True
95
def _warn_if_deprecated(self):
96
# This class isn't deprecated
99
def _inventory_add_lines(self, inv_vf, revid, parents, lines, check_content):
100
return inv_vf.add_lines_with_ghosts(revid, parents, lines,
101
check_content=check_content)[0]
130
104
def _all_revision_ids(self):
131
105
"""See Repository.all_revision_ids()."""
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',)])
106
# Knits get the revision graph from the index of the revision knit, so
107
# it's always possible even if they're on an unlistable transport.
108
return self._revision_store.all_revision_ids(self.get_transaction())
110
def fileid_involved_between_revs(self, from_revid, to_revid):
111
"""Find file_id(s) which are involved in the changes between revisions.
113
This determines the set of revisions which are involved, and then
114
finds all file ids affected by those revisions.
116
vf = self._get_revision_vf()
117
from_set = set(vf.get_ancestry(from_revid))
118
to_set = set(vf.get_ancestry(to_revid))
119
changed = to_set.difference(from_set)
120
return self._fileid_involved_by_set(changed)
122
def fileid_involved(self, last_revid=None):
123
"""Find all file_ids modified in the ancestry of last_revid.
125
:param last_revid: If None, last_revision() will be used.
128
changed = set(self.all_revision_ids())
130
changed = set(self.get_ancestry(last_revid))
133
return self._fileid_involved_by_set(changed)
136
def get_ancestry(self, revision_id, topo_sorted=True):
137
"""Return a list of revision-ids integrated by a revision.
139
This is topologically sorted, unless 'topo_sorted' is specified as
142
if _mod_revision.is_null(revision_id):
144
vf = self._get_revision_vf()
146
return [None] + vf.get_ancestry(revision_id, topo_sorted)
147
except errors.RevisionNotPresent:
148
raise errors.NoSuchRevision(self, revision_id)
151
def get_data_stream(self, revision_ids):
152
"""See Repository.get_data_stream."""
153
item_keys = self.item_keys_introduced_by(revision_ids)
154
for knit_kind, file_id, versions in item_keys:
156
if knit_kind == 'file':
157
name = ('file', file_id)
158
knit = self.weave_store.get_weave_or_empty(
159
file_id, self.get_transaction())
160
elif knit_kind == 'inventory':
161
knit = self.get_inventory_weave()
162
elif knit_kind == 'revisions':
163
knit = self._revision_store.get_revision_file(
164
self.get_transaction())
165
elif knit_kind == 'signatures':
166
knit = self._revision_store.get_signature_file(
167
self.get_transaction())
169
raise AssertionError('Unknown knit kind %r' % (knit_kind,))
170
yield name, _get_stream_as_bytes(knit, versions)
187
173
def get_revision(self, revision_id):
189
175
revision_id = osutils.safe_revision_id(revision_id)
190
176
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()
179
def get_revision_graph(self, revision_id=None):
180
"""Return a dictionary containing the revision graph.
182
:param revision_id: The revision_id to get a graph from. If None, then
183
the entire revision graph is returned. This is a deprecated mode of
184
operation and will be removed in the future.
185
:return: a dictionary of revision_id->revision_parents_list.
187
if 'evil' in debug.debug_flags:
189
"get_revision_graph scales with size of history.")
190
# special case NULL_REVISION
191
if revision_id == _mod_revision.NULL_REVISION:
193
a_weave = self._get_revision_vf()
194
if revision_id is None:
195
return a_weave.get_graph()
196
if revision_id not in a_weave:
197
raise errors.NoSuchRevision(self, revision_id)
199
# add what can be reached from revision_id
200
return a_weave.get_graph([revision_id])
203
def get_revision_graph_with_ghosts(self, revision_ids=None):
204
"""Return a graph of the revisions with ghosts marked as applicable.
206
:param revision_ids: an iterable of revisions to graph or None for all.
207
:return: a Graph object with the graph reachable from revision_ids.
209
if 'evil' in debug.debug_flags:
211
"get_revision_graph_with_ghosts scales with size of history.")
212
result = deprecated_graph.Graph()
213
vf = self._get_revision_vf()
214
versions = set(vf.versions())
216
pending = set(self.all_revision_ids())
219
pending = set(revision_ids)
220
# special case NULL_REVISION
221
if _mod_revision.NULL_REVISION in pending:
222
pending.remove(_mod_revision.NULL_REVISION)
223
required = set(pending)
226
revision_id = pending.pop()
227
if not revision_id in versions:
228
if revision_id in required:
229
raise errors.NoSuchRevision(self, revision_id)
231
result.add_ghost(revision_id)
232
# mark it as done so we don't try for it again.
233
done.add(revision_id)
235
parent_ids = vf.get_parents_with_ghosts(revision_id)
236
for parent_id in parent_ids:
237
# is this queued or done ?
238
if (parent_id not in pending and
239
parent_id not in done):
241
pending.add(parent_id)
242
result.add_node(revision_id, parent_ids)
243
done.add(revision_id)
246
def _get_revision_vf(self):
247
""":return: a versioned file containing the revisions."""
248
vf = self._revision_store.get_revision_file(self.get_transaction())
251
def _get_history_vf(self):
252
"""Get a versionedfile whose history graph reflects all revisions.
254
For knit repositories, this is the revision knit.
256
return self._get_revision_vf()
205
258
@needs_write_lock
206
259
def reconcile(self, other=None, thorough=False):
209
262
reconciler = KnitReconciler(self, thorough=thorough)
210
263
reconciler.reconcile()
211
264
return reconciler
266
def revision_parents(self, revision_id):
267
return self._get_revision_vf().get_parents(revision_id)
213
269
def _make_parents_provider(self):
214
return _KnitsParentsProvider(self.revisions)
217
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
218
"""Bzr repository knit format (generalized).
270
return _KnitParentsProvider(self._get_revision_vf())
272
def _find_inconsistent_revision_parents(self):
273
"""Find revisions with different parent lists in the revision object
274
and in the index graph.
276
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
277
parents-in-revision).
279
assert self.is_locked()
280
vf = self._get_revision_vf()
281
for index_version in vf.versions():
282
parents_according_to_index = tuple(vf.get_parents_with_ghosts(
284
revision = self.get_revision(index_version)
285
parents_according_to_revision = tuple(revision.parent_ids)
286
if parents_according_to_index != parents_according_to_revision:
287
yield (index_version, parents_according_to_index,
288
parents_according_to_revision)
290
def _check_for_inconsistent_revision_parents(self):
291
inconsistencies = list(self._find_inconsistent_revision_parents())
293
raise errors.BzrCheckError(
294
"Revision knit has inconsistent parents.")
296
def revision_graph_can_have_wrong_parents(self):
297
# The revision.kndx could potentially claim a revision has a different
298
# parent to the revision text.
302
class RepositoryFormatKnit(MetaDirRepositoryFormat):
303
"""Bzr repository knit format (generalized).
220
305
This repository format has:
221
306
- knits for file texts and inventory
237
322
_commit_builder_class = None
238
323
# Set this attribute in derived clases to control the _serializer that the
239
324
# repository objects will have passed to their constructor.
241
def _serializer(self):
242
return xml5.serializer_v5
325
_serializer = xml5.serializer_v5
243
326
# Knit based repositories handle ghosts reasonably well.
244
327
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
def _get_control_store(self, repo_transport, control_files):
330
"""Return the control store for this repository."""
331
return VersionedFileStore(
334
file_mode=control_files._file_mode,
335
versionedfile_class=knit.KnitVersionedFile,
336
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
339
def _get_revision_store(self, repo_transport, control_files):
340
"""See RepositoryFormat._get_revision_store()."""
341
versioned_file_store = VersionedFileStore(
343
file_mode=control_files._file_mode,
346
versionedfile_class=knit.KnitVersionedFile,
347
versionedfile_kwargs={'delta':False,
348
'factory':knit.KnitPlainFactory(),
352
return KnitRevisionStore(versioned_file_store)
354
def _get_text_store(self, transport, control_files):
355
"""See RepositoryFormat._get_text_store()."""
356
return self._get_versioned_file_store('knits',
359
versionedfile_class=knit.KnitVersionedFile,
360
versionedfile_kwargs={
361
'create_parent_dir':True,
363
'dir_mode':control_files._dir_mode,
289
367
def initialize(self, a_bzrdir, shared=False):
290
368
"""Create a knit format 1 repository.
294
372
:param shared: If true the repository will be initialized as a shared
297
trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
375
mutter('creating repository in %s.', a_bzrdir.transport.base)
300
378
utf8_files = [('format', self.get_format_string())]
302
380
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
303
381
repo_transport = a_bzrdir.get_repository_transport(None)
304
382
control_files = lockable_files.LockableFiles(repo_transport,
305
383
'lock', lockdir.LockDir)
384
control_store = self._get_control_store(repo_transport, control_files)
306
385
transaction = transactions.WriteTransaction()
307
result = self.open(a_bzrdir=a_bzrdir, _found=True)
386
# trigger a write of the inventory store.
387
control_store.get_weave_or_empty('inventory', transaction)
388
_revision_store = self._get_revision_store(repo_transport, control_files)
309
389
# the revision id here is irrelevant: it will not be stored, and cannot
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)
391
_revision_store.has_revision_id('A', transaction)
392
_revision_store.get_signature_file(transaction)
393
return self.open(a_bzrdir=a_bzrdir, _found=True)
318
395
def open(self, a_bzrdir, _found=False, _override_transport=None):
319
396
"""See RepositoryFormat.open().
321
398
:param _override_transport: INTERNAL USE ONLY. Allows opening the
322
399
repository at a slightly different url
323
400
than normal. I.e. during 'upgrade'.
326
format = RepositoryFormatMetaDir.find_format(a_bzrdir)
403
format = RepositoryFormat.find_format(a_bzrdir)
404
assert format.__class__ == self.__class__
327
405
if _override_transport is not None:
328
406
repo_transport = _override_transport
330
408
repo_transport = a_bzrdir.get_repository_transport(None)
331
409
control_files = lockable_files.LockableFiles(repo_transport,
332
410
'lock', lockdir.LockDir)
333
repo = self.repository_class(_format=self,
411
text_store = self._get_text_store(repo_transport, control_files)
412
control_store = self._get_control_store(repo_transport, control_files)
413
_revision_store = self._get_revision_store(repo_transport, control_files)
414
return self.repository_class(_format=self,
334
415
a_bzrdir=a_bzrdir,
335
416
control_files=control_files,
417
_revision_store=_revision_store,
418
control_store=control_store,
419
text_store=text_store,
336
420
_commit_builder_class=self._commit_builder_class,
337
421
_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
347
424
class RepositoryFormatKnit1(RepositoryFormatKnit):
398
475
repository_class = KnitRepository
399
_commit_builder_class = VersionedFileRootCommitBuilder
476
_commit_builder_class = RootCommitBuilder
400
477
rich_root_data = True
402
478
supports_tree_reference = True
404
def _serializer(self):
405
return xml7.serializer_v7
479
_serializer = xml7.serializer_v7
407
481
def _get_matching_bzrdir(self):
408
return controldir.format_registry.make_bzrdir('dirstate-with-subtree')
482
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
410
484
def _ignore_setting_bzrdir(self, format):
413
487
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
416
def get_format_string(cls):
489
def check_conversion_target(self, target_format):
490
if not target_format.rich_root_data:
491
raise errors.BadConversionTarget(
492
'Does not support rich root data.', target_format)
493
if not getattr(target_format, 'supports_tree_reference', False):
494
raise errors.BadConversionTarget(
495
'Does not support nested trees', target_format)
497
def get_format_string(self):
417
498
"""See RepositoryFormat.get_format_string()."""
418
499
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
422
503
return "Knit repository format 3"
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
506
def _get_stream_as_bytes(knit, required_versions):
507
"""Generate a serialised data stream.
509
The format is a bencoding of a list. The first element of the list is a
510
string of the format signature, then each subsequent element is a list
511
corresponding to a record. Those lists contain:
518
:returns: a bencoded list.
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
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)
520
knit_stream = knit.get_data_stream(required_versions)
521
format_signature, data_list, callable = knit_stream
523
data.append(format_signature)
524
for version, options, length, parents in data_list:
525
data.append([version, options, parents, callable(length)])
526
return bencode.bencode(data)
added
removed
bzrlib/repofmt/knitrepo.py
