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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
from bzrlib.lazy_import import lazy_import
18
18
lazy_import(globals(), """
22
from bzrlib.store import revision
23
from bzrlib.store.revision.knit import KnitRevisionStore
21
25
from bzrlib import (
28
revision as _mod_revision,
37
40
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
41
from bzrlib.repository import (
44
MetaDirRepositoryFormat,
43
from bzrlib.vf_repository import (
44
InterSameDataRepository,
45
MetaDirVersionedFileRepository,
46
MetaDirVersionedFileRepositoryFormat,
47
VersionedFileCommitBuilder,
48
VersionedFileRootCommitBuilder,
50
from bzrlib import symbol_versioning
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
53
54
class _KnitParentsProvider(object):
117
94
_commit_builder_class = None
118
95
_serializer = None
120
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
122
super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
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)
123
101
self._commit_builder_class = _commit_builder_class
124
102
self._serializer = _serializer
125
103
self._reconcile_fixes_text_parents = True
105
def _warn_if_deprecated(self):
106
# This class isn't deprecated
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]
128
114
def _all_revision_ids(self):
129
115
"""See Repository.all_revision_ids()."""
130
return [key[0] for key in self.revisions.keys()]
132
def _activate_new_inventory(self):
133
"""Put a replacement inventory.new into use as inventories."""
134
# Copy the content across
136
t.copy('inventory.new.kndx', 'inventory.kndx')
138
t.copy('inventory.new.knit', 'inventory.knit')
139
except errors.NoSuchFile:
140
# empty inventories knit
141
t.delete('inventory.knit')
142
# delete the temp inventory
143
t.delete('inventory.new.kndx')
145
t.delete('inventory.new.knit')
146
except errors.NoSuchFile:
147
# empty inventories knit
149
# Force index reload (sanity check)
150
self.inventories._index._reset_cache()
151
self.inventories.keys()
153
def _backup_inventory(self):
155
t.copy('inventory.kndx', 'inventory.backup.kndx')
156
t.copy('inventory.knit', 'inventory.backup.knit')
158
def _move_file_id(self, from_id, to_id):
159
t = self._transport.clone('knits')
160
from_rel_url = self.texts._index._mapper.map((from_id, None))
161
to_rel_url = self.texts._index._mapper.map((to_id, None))
162
# We expect both files to always exist in this case.
163
for suffix in ('.knit', '.kndx'):
164
t.rename(from_rel_url + suffix, to_rel_url + suffix)
166
def _remove_file_id(self, file_id):
167
t = self._transport.clone('knits')
168
rel_url = self.texts._index._mapper.map((file_id, None))
169
for suffix in ('.kndx', '.knit'):
171
t.delete(rel_url + suffix)
172
except errors.NoSuchFile:
175
def _temp_inventories(self):
176
result = self._format._get_inventories(self._transport, self,
178
# Reconciling when the output has no revisions would result in no
179
# writes - but we want to ensure there is an inventory for
180
# compatibility with older clients that don't lazy-load.
181
result.get_parent_map([('A',)])
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())
120
def fileid_involved_between_revs(self, from_revid, to_revid):
121
"""Find file_id(s) which are involved in the changes between revisions.
123
This determines the set of revisions which are involved, and then
124
finds all file ids affected by those revisions.
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)
132
def fileid_involved(self, last_revid=None):
133
"""Find all file_ids modified in the ancestry of last_revid.
135
:param last_revid: If None, last_revision() will be used.
138
changed = set(self.all_revision_ids())
140
changed = set(self.get_ancestry(last_revid))
143
return self._fileid_involved_by_set(changed)
146
def get_ancestry(self, revision_id, topo_sorted=True):
147
"""Return a list of revision-ids integrated by a revision.
149
This is topologically sorted, unless 'topo_sorted' is specified as
152
if _mod_revision.is_null(revision_id):
154
vf = self._get_revision_vf()
156
return [None] + vf.get_ancestry(revision_id, topo_sorted)
157
except errors.RevisionNotPresent:
158
raise errors.NoSuchRevision(self, revision_id)
160
@symbol_versioning.deprecated_method(symbol_versioning.one_two)
162
def get_data_stream(self, revision_ids):
163
"""See Repository.get_data_stream.
165
Deprecated in 1.2 for get_data_stream_for_search.
167
search_result = self.revision_ids_to_search_result(set(revision_ids))
168
return self.get_data_stream_for_search(search_result)
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:
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())
189
raise AssertionError('Unknown knit kind %r' % (knit_kind,))
190
yield name, _get_stream_as_bytes(knit, versions)
185
193
def get_revision(self, revision_id):
187
195
revision_id = osutils.safe_revision_id(revision_id)
188
196
return self.get_revision_reconcile(revision_id)
190
def _refresh_data(self):
191
if not self.is_locked():
193
if self.is_in_write_group():
194
raise IsInWriteGroupError(self)
195
# Create a new transaction to force all knits to see the scope change.
196
# This is safe because we're outside a write group.
197
self.control_files._finish_transaction()
198
if self.is_write_locked():
199
self.control_files._set_write_transaction()
201
self.control_files._set_read_transaction()
199
def get_revision_graph(self, revision_id=None):
200
"""Return a dictionary containing the revision graph.
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.
207
if 'evil' in debug.debug_flags:
209
"get_revision_graph scales with size of history.")
210
# special case NULL_REVISION
211
if revision_id == _mod_revision.NULL_REVISION:
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)
219
# add what can be reached from revision_id
220
return a_weave.get_graph([revision_id])
223
@symbol_versioning.deprecated_method(symbol_versioning.one_three)
224
def get_revision_graph_with_ghosts(self, revision_ids=None):
225
"""Return a graph of the revisions with ghosts marked as applicable.
227
:param revision_ids: an iterable of revisions to graph or None for all.
228
:return: a Graph object with the graph reachable from revision_ids.
230
if 'evil' in debug.debug_flags:
232
"get_revision_graph_with_ghosts scales with size of history.")
233
result = deprecated_graph.Graph()
234
vf = self._get_revision_vf()
235
versions = set(vf.versions())
237
pending = set(self.all_revision_ids())
240
pending = set(revision_ids)
241
# special case NULL_REVISION
242
if _mod_revision.NULL_REVISION in pending:
243
pending.remove(_mod_revision.NULL_REVISION)
244
required = set(pending)
247
revision_id = pending.pop()
248
if not revision_id in versions:
249
if revision_id in required:
250
raise errors.NoSuchRevision(self, revision_id)
252
result.add_ghost(revision_id)
253
# mark it as done so we don't try for it again.
254
done.add(revision_id)
256
parent_ids = vf.get_parents_with_ghosts(revision_id)
257
for parent_id in parent_ids:
258
# is this queued or done ?
259
if (parent_id not in pending and
260
parent_id not in done):
262
pending.add(parent_id)
263
result.add_node(revision_id, parent_ids)
264
done.add(revision_id)
267
def _get_revision_vf(self):
268
""":return: a versioned file containing the revisions."""
269
vf = self._revision_store.get_revision_file(self.get_transaction())
272
def _get_history_vf(self):
273
"""Get a versionedfile whose history graph reflects all revisions.
275
For knit repositories, this is the revision knit.
277
return self._get_revision_vf()
279
def has_revisions(self, revision_ids):
280
"""See Repository.has_revisions()."""
282
transaction = self.get_transaction()
283
for revision_id in revision_ids:
284
if self._revision_store.has_revision_id(revision_id, transaction):
285
result.add(revision_id)
203
288
@needs_write_lock
204
289
def reconcile(self, other=None, thorough=False):
207
292
reconciler = KnitReconciler(self, thorough=thorough)
208
293
reconciler.reconcile()
209
294
return reconciler
296
def revision_parents(self, revision_id):
297
return self._get_revision_vf().get_parents(revision_id)
211
299
def _make_parents_provider(self):
212
return _KnitsParentsProvider(self.revisions)
215
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
216
"""Bzr repository knit format (generalized).
300
return _KnitParentsProvider(self._get_revision_vf())
302
def _find_inconsistent_revision_parents(self):
303
"""Find revisions with different parent lists in the revision object
304
and in the index graph.
306
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
307
parents-in-revision).
309
assert self.is_locked()
310
vf = self._get_revision_vf()
311
for index_version in vf.versions():
312
parents_according_to_index = tuple(vf.get_parents_with_ghosts(
314
revision = self.get_revision(index_version)
315
parents_according_to_revision = tuple(revision.parent_ids)
316
if parents_according_to_index != parents_according_to_revision:
317
yield (index_version, parents_according_to_index,
318
parents_according_to_revision)
320
def _check_for_inconsistent_revision_parents(self):
321
inconsistencies = list(self._find_inconsistent_revision_parents())
323
raise errors.BzrCheckError(
324
"Revision knit has inconsistent parents.")
326
def revision_graph_can_have_wrong_parents(self):
327
# The revision.kndx could potentially claim a revision has a different
328
# parent to the revision text.
332
class RepositoryFormatKnit(MetaDirRepositoryFormat):
333
"""Bzr repository knit format (generalized).
218
335
This repository format has:
219
336
- knits for file texts and inventory
235
352
_commit_builder_class = None
236
353
# Set this attribute in derived clases to control the _serializer that the
237
354
# repository objects will have passed to their constructor.
239
def _serializer(self):
240
return xml5.serializer_v5
355
_serializer = xml5.serializer_v5
241
356
# Knit based repositories handle ghosts reasonably well.
242
357
supports_ghosts = True
243
358
# External lookups are not supported in this format.
244
359
supports_external_lookups = False
246
supports_chks = False
247
_fetch_order = 'topological'
248
_fetch_uses_deltas = True
250
supports_funky_characters = True
251
# The revision.kndx could potentially claim a revision has a different
252
# parent to the revision text.
253
revision_graph_can_have_wrong_parents = True
255
def _get_inventories(self, repo_transport, repo, name='inventory'):
256
mapper = versionedfile.ConstantMapper(name)
257
index = _mod_knit._KndxIndex(repo_transport, mapper,
258
repo.get_transaction, repo.is_write_locked, repo.is_locked)
259
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
260
return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
262
def _get_revisions(self, repo_transport, repo):
263
mapper = versionedfile.ConstantMapper('revisions')
264
index = _mod_knit._KndxIndex(repo_transport, mapper,
265
repo.get_transaction, repo.is_write_locked, repo.is_locked)
266
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
267
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
270
def _get_signatures(self, repo_transport, repo):
271
mapper = versionedfile.ConstantMapper('signatures')
272
index = _mod_knit._KndxIndex(repo_transport, mapper,
273
repo.get_transaction, repo.is_write_locked, repo.is_locked)
274
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
275
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
278
def _get_texts(self, repo_transport, repo):
279
mapper = versionedfile.HashEscapedPrefixMapper()
280
base_transport = repo_transport.clone('knits')
281
index = _mod_knit._KndxIndex(base_transport, mapper,
282
repo.get_transaction, repo.is_write_locked, repo.is_locked)
283
access = _mod_knit._KnitKeyAccess(base_transport, mapper)
284
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
361
def _get_control_store(self, repo_transport, control_files):
362
"""Return the control store for this repository."""
363
return VersionedFileStore(
366
file_mode=control_files._file_mode,
367
versionedfile_class=knit.KnitVersionedFile,
368
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
371
def _get_revision_store(self, repo_transport, control_files):
372
"""See RepositoryFormat._get_revision_store()."""
373
versioned_file_store = VersionedFileStore(
375
file_mode=control_files._file_mode,
378
versionedfile_class=knit.KnitVersionedFile,
379
versionedfile_kwargs={'delta':False,
380
'factory':knit.KnitPlainFactory(),
384
return KnitRevisionStore(versioned_file_store)
386
def _get_text_store(self, transport, control_files):
387
"""See RepositoryFormat._get_text_store()."""
388
return self._get_versioned_file_store('knits',
391
versionedfile_class=knit.KnitVersionedFile,
392
versionedfile_kwargs={
393
'create_parent_dir':True,
395
'dir_mode':control_files._dir_mode,
287
399
def initialize(self, a_bzrdir, shared=False):
288
400
"""Create a knit format 1 repository.
292
404
:param shared: If true the repository will be initialized as a shared
295
trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
407
mutter('creating repository in %s.', a_bzrdir.transport.base)
298
410
utf8_files = [('format', self.get_format_string())]
300
412
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
301
413
repo_transport = a_bzrdir.get_repository_transport(None)
302
414
control_files = lockable_files.LockableFiles(repo_transport,
303
415
'lock', lockdir.LockDir)
416
control_store = self._get_control_store(repo_transport, control_files)
304
417
transaction = transactions.WriteTransaction()
305
result = self.open(a_bzrdir=a_bzrdir, _found=True)
418
# trigger a write of the inventory store.
419
control_store.get_weave_or_empty('inventory', transaction)
420
_revision_store = self._get_revision_store(repo_transport, control_files)
307
421
# the revision id here is irrelevant: it will not be stored, and cannot
308
# already exist, we do this to create files on disk for older clients.
309
result.inventories.get_parent_map([('A',)])
310
result.revisions.get_parent_map([('A',)])
311
result.signatures.get_parent_map([('A',)])
313
self._run_post_repo_init_hooks(result, a_bzrdir, shared)
423
_revision_store.has_revision_id('A', transaction)
424
_revision_store.get_signature_file(transaction)
425
return self.open(a_bzrdir=a_bzrdir, _found=True)
316
427
def open(self, a_bzrdir, _found=False, _override_transport=None):
317
428
"""See RepositoryFormat.open().
319
430
:param _override_transport: INTERNAL USE ONLY. Allows opening the
320
431
repository at a slightly different url
321
432
than normal. I.e. during 'upgrade'.
324
435
format = RepositoryFormat.find_format(a_bzrdir)
436
assert format.__class__ == self.__class__
325
437
if _override_transport is not None:
326
438
repo_transport = _override_transport
328
440
repo_transport = a_bzrdir.get_repository_transport(None)
329
441
control_files = lockable_files.LockableFiles(repo_transport,
330
442
'lock', lockdir.LockDir)
331
repo = self.repository_class(_format=self,
443
text_store = self._get_text_store(repo_transport, control_files)
444
control_store = self._get_control_store(repo_transport, control_files)
445
_revision_store = self._get_revision_store(repo_transport, control_files)
446
return self.repository_class(_format=self,
332
447
a_bzrdir=a_bzrdir,
333
448
control_files=control_files,
449
_revision_store=_revision_store,
450
control_store=control_store,
451
text_store=text_store,
334
452
_commit_builder_class=self._commit_builder_class,
335
453
_serializer=self._serializer)
336
repo.revisions = self._get_revisions(repo_transport, repo)
337
repo.signatures = self._get_signatures(repo_transport, repo)
338
repo.inventories = self._get_inventories(repo_transport, repo)
339
repo.texts = self._get_texts(repo_transport, repo)
340
repo.chk_bytes = None
341
repo._transport = repo_transport
345
456
class RepositoryFormatKnit1(RepositoryFormatKnit):
459
579
return "Knit repository format 4"
462
class InterKnitRepo(InterSameDataRepository):
463
"""Optimised code paths between Knit based repositories."""
466
def _get_repo_format_to_test(self):
467
return RepositoryFormatKnit1()
470
def is_compatible(source, target):
471
"""Be compatible with known Knit formats.
473
We don't test for the stores being of specific types because that
474
could lead to confusing results, and there is no need to be
478
are_knits = (isinstance(source._format, RepositoryFormatKnit) and
479
isinstance(target._format, RepositoryFormatKnit))
480
except AttributeError:
482
return are_knits and InterRepository._same_model(source, target)
485
def search_missing_revision_ids(self,
486
revision_id=symbol_versioning.DEPRECATED_PARAMETER,
487
find_ghosts=True, revision_ids=None, if_present_ids=None,
489
"""See InterRepository.search_missing_revision_ids()."""
490
if symbol_versioning.deprecated_passed(revision_id):
491
symbol_versioning.warn(
492
'search_missing_revision_ids(revision_id=...) was '
493
'deprecated in 2.4. Use revision_ids=[...] instead.',
494
DeprecationWarning, stacklevel=2)
495
if revision_ids is not None:
496
raise AssertionError(
497
'revision_ids is mutually exclusive with revision_id')
498
if revision_id is not None:
499
revision_ids = [revision_id]
501
source_ids_set = self._present_source_revisions_for(
502
revision_ids, if_present_ids)
503
# source_ids is the worst possible case we may need to pull.
504
# now we want to filter source_ids against what we actually
505
# have in target, but don't try to check for existence where we know
506
# we do not have a revision as that would be pointless.
507
target_ids = set(self.target.all_revision_ids())
508
possibly_present_revisions = target_ids.intersection(source_ids_set)
509
actually_present_revisions = set(
510
self.target._eliminate_revisions_not_present(possibly_present_revisions))
511
required_revisions = source_ids_set.difference(actually_present_revisions)
512
if revision_ids is not None:
513
# we used get_ancestry to determine source_ids then we are assured all
514
# revisions referenced are present as they are installed in topological order.
515
# and the tip revision was validated by get_ancestry.
516
result_set = required_revisions
518
# if we just grabbed the possibly available ids, then
519
# we only have an estimate of whats available and need to validate
520
# that against the revision records.
522
self.source._eliminate_revisions_not_present(required_revisions))
523
if limit is not None:
524
topo_ordered = self.source.get_graph().iter_topo_order(result_set)
525
result_set = set(itertools.islice(topo_ordered, limit))
526
return self.source.revision_ids_to_search_result(result_set)
529
InterRepository.register_optimiser(InterKnitRepo)
582
def _get_stream_as_bytes(knit, required_versions):
583
"""Generate a serialised data stream.
585
The format is a bencoding of a list. The first element of the list is a
586
string of the format signature, then each subsequent element is a list
587
corresponding to a record. Those lists contain:
594
:returns: a bencoded list.
596
knit_stream = knit.get_data_stream(required_versions)
597
format_signature, data_list, callable = knit_stream
599
data.append(format_signature)
600
for version, options, length, parents in data_list:
601
data.append([version, options, parents, callable(length)])
602
return bencode.bencode(data)
added
removed
bzrlib/repofmt/knitrepo.py
