1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
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.
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.
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
17
from bzrlib.lazy_import import lazy_import
18
lazy_import(globals(), """
22
from bzrlib.store import revision
23
from bzrlib.store.revision.knit import KnitRevisionStore
40
from bzrlib.decorators import needs_read_lock, needs_write_lock
41
from bzrlib.repository import (
44
MetaDirRepositoryFormat,
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
54
class _KnitParentsProvider(object):
56
def __init__(self, knit):
60
return 'KnitParentsProvider(%r)' % self._knit
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]
68
def get_parent_map(self, keys):
69
"""See graph._StackedParentsProvider.get_parent_map"""
71
for revision_id in keys:
72
if revision_id == _mod_revision.NULL_REVISION:
73
parent_map[revision_id] = ()
77
self._knit.get_parents_with_ghosts(revision_id))
78
except errors.RevisionNotPresent:
82
parents = (_mod_revision.NULL_REVISION,)
83
parent_map[revision_id] = parents
87
class KnitRepository(MetaDirRepository):
88
"""Knit format repository."""
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
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
control_store.get_scope = self.get_transaction
105
text_store.get_scope = self.get_transaction
106
_revision_store.get_scope = self.get_transaction
108
def _warn_if_deprecated(self):
109
# This class isn't deprecated
112
def _inventory_add_lines(self, inv_vf, revid, parents, lines, check_content):
113
return inv_vf.add_lines_with_ghosts(revid, parents, lines,
114
check_content=check_content)[0]
117
def _all_revision_ids(self):
118
"""See Repository.all_revision_ids()."""
119
# Knits get the revision graph from the index of the revision knit, so
120
# it's always possible even if they're on an unlistable transport.
121
return self._revision_store.all_revision_ids(self.get_transaction())
123
def fileid_involved_between_revs(self, from_revid, to_revid):
124
"""Find file_id(s) which are involved in the changes between revisions.
126
This determines the set of revisions which are involved, and then
127
finds all file ids affected by those revisions.
129
vf = self._get_revision_vf()
130
from_set = set(vf.get_ancestry(from_revid))
131
to_set = set(vf.get_ancestry(to_revid))
132
changed = to_set.difference(from_set)
133
return self._fileid_involved_by_set(changed)
135
def fileid_involved(self, last_revid=None):
136
"""Find all file_ids modified in the ancestry of last_revid.
138
:param last_revid: If None, last_revision() will be used.
141
changed = set(self.all_revision_ids())
143
changed = set(self.get_ancestry(last_revid))
146
return self._fileid_involved_by_set(changed)
149
def get_ancestry(self, revision_id, topo_sorted=True):
150
"""Return a list of revision-ids integrated by a revision.
152
This is topologically sorted, unless 'topo_sorted' is specified as
155
if _mod_revision.is_null(revision_id):
157
vf = self._get_revision_vf()
159
return [None] + vf.get_ancestry(revision_id, topo_sorted)
160
except errors.RevisionNotPresent:
161
raise errors.NoSuchRevision(self, revision_id)
163
@symbol_versioning.deprecated_method(symbol_versioning.one_two)
165
def get_data_stream(self, revision_ids):
166
"""See Repository.get_data_stream.
168
Deprecated in 1.2 for get_data_stream_for_search.
170
search_result = self.revision_ids_to_search_result(set(revision_ids))
171
return self.get_data_stream_for_search(search_result)
174
def get_data_stream_for_search(self, search):
175
"""See Repository.get_data_stream_for_search."""
176
item_keys = self.item_keys_introduced_by(search.get_keys())
177
for knit_kind, file_id, versions in item_keys:
179
if knit_kind == 'file':
180
name = ('file', file_id)
181
knit = self.weave_store.get_weave_or_empty(
182
file_id, self.get_transaction())
183
elif knit_kind == 'inventory':
184
knit = self.get_inventory_weave()
185
elif knit_kind == 'revisions':
186
knit = self._revision_store.get_revision_file(
187
self.get_transaction())
188
elif knit_kind == 'signatures':
189
knit = self._revision_store.get_signature_file(
190
self.get_transaction())
192
raise AssertionError('Unknown knit kind %r' % (knit_kind,))
193
yield name, _get_stream_as_bytes(knit, versions)
196
def get_revision(self, revision_id):
197
"""Return the Revision object for a named revision"""
198
revision_id = osutils.safe_revision_id(revision_id)
199
return self.get_revision_reconcile(revision_id)
201
@symbol_versioning.deprecated_method(symbol_versioning.one_four)
203
def get_revision_graph(self, revision_id=None):
204
"""Return a dictionary containing the revision graph.
206
:param revision_id: The revision_id to get a graph from. If None, then
207
the entire revision graph is returned. This is a deprecated mode of
208
operation and will be removed in the future.
209
:return: a dictionary of revision_id->revision_parents_list.
211
if 'evil' in debug.debug_flags:
213
"get_revision_graph scales with size of history.")
214
# special case NULL_REVISION
215
if revision_id == _mod_revision.NULL_REVISION:
217
a_weave = self._get_revision_vf()
218
if revision_id is None:
219
return a_weave.get_graph()
220
if revision_id not in a_weave:
221
raise errors.NoSuchRevision(self, revision_id)
223
# add what can be reached from revision_id
224
return a_weave.get_graph([revision_id])
227
@symbol_versioning.deprecated_method(symbol_versioning.one_three)
228
def get_revision_graph_with_ghosts(self, revision_ids=None):
229
"""Return a graph of the revisions with ghosts marked as applicable.
231
:param revision_ids: an iterable of revisions to graph or None for all.
232
:return: a Graph object with the graph reachable from revision_ids.
234
if 'evil' in debug.debug_flags:
236
"get_revision_graph_with_ghosts scales with size of history.")
237
result = deprecated_graph.Graph()
238
vf = self._get_revision_vf()
239
versions = set(vf.versions())
241
pending = set(self.all_revision_ids())
244
pending = set(revision_ids)
245
# special case NULL_REVISION
246
if _mod_revision.NULL_REVISION in pending:
247
pending.remove(_mod_revision.NULL_REVISION)
248
required = set(pending)
251
revision_id = pending.pop()
252
if not revision_id in versions:
253
if revision_id in required:
254
raise errors.NoSuchRevision(self, revision_id)
256
result.add_ghost(revision_id)
257
# mark it as done so we don't try for it again.
258
done.add(revision_id)
260
parent_ids = vf.get_parents_with_ghosts(revision_id)
261
for parent_id in parent_ids:
262
# is this queued or done ?
263
if (parent_id not in pending and
264
parent_id not in done):
266
pending.add(parent_id)
267
result.add_node(revision_id, parent_ids)
268
done.add(revision_id)
271
def _get_revision_vf(self):
272
""":return: a versioned file containing the revisions."""
273
vf = self._revision_store.get_revision_file(self.get_transaction())
276
def has_revisions(self, revision_ids):
277
"""See Repository.has_revisions()."""
279
transaction = self.get_transaction()
280
for revision_id in revision_ids:
281
if self._revision_store.has_revision_id(revision_id, transaction):
282
result.add(revision_id)
286
def reconcile(self, other=None, thorough=False):
287
"""Reconcile this repository."""
288
from bzrlib.reconcile import KnitReconciler
289
reconciler = KnitReconciler(self, thorough=thorough)
290
reconciler.reconcile()
293
def revision_parents(self, revision_id):
294
return self._get_revision_vf().get_parents(revision_id)
296
def _make_parents_provider(self):
297
return _KnitParentsProvider(self._get_revision_vf())
299
def _find_inconsistent_revision_parents(self):
300
"""Find revisions with different parent lists in the revision object
301
and in the index graph.
303
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
304
parents-in-revision).
306
assert self.is_locked()
307
vf = self._get_revision_vf()
308
for index_version in vf.versions():
309
parents_according_to_index = tuple(vf.get_parents_with_ghosts(
311
revision = self.get_revision(index_version)
312
parents_according_to_revision = tuple(revision.parent_ids)
313
if parents_according_to_index != parents_according_to_revision:
314
yield (index_version, parents_according_to_index,
315
parents_according_to_revision)
317
def _check_for_inconsistent_revision_parents(self):
318
inconsistencies = list(self._find_inconsistent_revision_parents())
320
raise errors.BzrCheckError(
321
"Revision knit has inconsistent parents.")
323
def revision_graph_can_have_wrong_parents(self):
324
# The revision.kndx could potentially claim a revision has a different
325
# parent to the revision text.
329
class RepositoryFormatKnit(MetaDirRepositoryFormat):
330
"""Bzr repository knit format (generalized).
332
This repository format has:
333
- knits for file texts and inventory
334
- hash subdirectory based stores.
335
- knits for revisions and signatures
336
- TextStores for revisions and signatures.
337
- a format marker of its own
338
- an optional 'shared-storage' flag
339
- an optional 'no-working-trees' flag
343
# Set this attribute in derived classes to control the repository class
344
# created by open and initialize.
345
repository_class = None
346
# Set this attribute in derived classes to control the
347
# _commit_builder_class that the repository objects will have passed to
349
_commit_builder_class = None
350
# Set this attribute in derived clases to control the _serializer that the
351
# repository objects will have passed to their constructor.
352
_serializer = xml5.serializer_v5
353
# Knit based repositories handle ghosts reasonably well.
354
supports_ghosts = True
355
# External lookups are not supported in this format.
356
supports_external_lookups = False
358
def _get_control_store(self, repo_transport, control_files):
359
"""Return the control store for this repository."""
360
return VersionedFileStore(
363
file_mode=control_files._file_mode,
364
versionedfile_class=knit.make_file_knit,
365
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
368
def _get_revision_store(self, repo_transport, control_files):
369
"""See RepositoryFormat._get_revision_store()."""
370
versioned_file_store = VersionedFileStore(
372
file_mode=control_files._file_mode,
375
versionedfile_class=knit.make_file_knit,
376
versionedfile_kwargs={'delta':False,
377
'factory':knit.KnitPlainFactory(),
381
return KnitRevisionStore(versioned_file_store)
383
def _get_text_store(self, transport, control_files):
384
"""See RepositoryFormat._get_text_store()."""
385
return self._get_versioned_file_store('knits',
388
versionedfile_class=knit.make_file_knit,
389
versionedfile_kwargs={
390
'create_parent_dir':True,
392
'dir_mode':control_files._dir_mode,
396
def initialize(self, a_bzrdir, shared=False):
397
"""Create a knit format 1 repository.
399
:param a_bzrdir: bzrdir to contain the new repository; must already
401
:param shared: If true the repository will be initialized as a shared
404
mutter('creating repository in %s.', a_bzrdir.transport.base)
407
utf8_files = [('format', self.get_format_string())]
409
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
410
repo_transport = a_bzrdir.get_repository_transport(None)
411
control_files = lockable_files.LockableFiles(repo_transport,
412
'lock', lockdir.LockDir)
413
control_store = self._get_control_store(repo_transport, control_files)
414
transaction = transactions.WriteTransaction()
415
# trigger a write of the inventory store.
416
control_store.get_weave_or_empty('inventory', transaction)
417
_revision_store = self._get_revision_store(repo_transport, control_files)
418
# the revision id here is irrelevant: it will not be stored, and cannot
420
_revision_store.has_revision_id('A', transaction)
421
_revision_store.get_signature_file(transaction)
422
return self.open(a_bzrdir=a_bzrdir, _found=True)
424
def open(self, a_bzrdir, _found=False, _override_transport=None):
425
"""See RepositoryFormat.open().
427
:param _override_transport: INTERNAL USE ONLY. Allows opening the
428
repository at a slightly different url
429
than normal. I.e. during 'upgrade'.
432
format = RepositoryFormat.find_format(a_bzrdir)
433
assert format.__class__ == self.__class__
434
if _override_transport is not None:
435
repo_transport = _override_transport
437
repo_transport = a_bzrdir.get_repository_transport(None)
438
control_files = lockable_files.LockableFiles(repo_transport,
439
'lock', lockdir.LockDir)
440
text_store = self._get_text_store(repo_transport, control_files)
441
control_store = self._get_control_store(repo_transport, control_files)
442
_revision_store = self._get_revision_store(repo_transport, control_files)
443
return self.repository_class(_format=self,
445
control_files=control_files,
446
_revision_store=_revision_store,
447
control_store=control_store,
448
text_store=text_store,
449
_commit_builder_class=self._commit_builder_class,
450
_serializer=self._serializer)
453
class RepositoryFormatKnit1(RepositoryFormatKnit):
454
"""Bzr repository knit format 1.
456
This repository format has:
457
- knits for file texts and inventory
458
- hash subdirectory based stores.
459
- knits for revisions and signatures
460
- TextStores for revisions and signatures.
461
- a format marker of its own
462
- an optional 'shared-storage' flag
463
- an optional 'no-working-trees' flag
466
This format was introduced in bzr 0.8.
469
repository_class = KnitRepository
470
_commit_builder_class = CommitBuilder
471
_serializer = xml5.serializer_v5
473
def __ne__(self, other):
474
return self.__class__ is not other.__class__
476
def get_format_string(self):
477
"""See RepositoryFormat.get_format_string()."""
478
return "Bazaar-NG Knit Repository Format 1"
480
def get_format_description(self):
481
"""See RepositoryFormat.get_format_description()."""
482
return "Knit repository format 1"
484
def check_conversion_target(self, target_format):
488
class RepositoryFormatKnit3(RepositoryFormatKnit):
489
"""Bzr repository knit format 3.
491
This repository format has:
492
- knits for file texts and inventory
493
- hash subdirectory based stores.
494
- knits for revisions and signatures
495
- TextStores for revisions and signatures.
496
- a format marker of its own
497
- an optional 'shared-storage' flag
498
- an optional 'no-working-trees' flag
500
- support for recording full info about the tree root
501
- support for recording tree-references
504
repository_class = KnitRepository
505
_commit_builder_class = RootCommitBuilder
506
rich_root_data = True
507
supports_tree_reference = True
508
_serializer = xml7.serializer_v7
510
def _get_matching_bzrdir(self):
511
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
513
def _ignore_setting_bzrdir(self, format):
516
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
518
def check_conversion_target(self, target_format):
519
if not target_format.rich_root_data:
520
raise errors.BadConversionTarget(
521
'Does not support rich root data.', target_format)
522
if not getattr(target_format, 'supports_tree_reference', False):
523
raise errors.BadConversionTarget(
524
'Does not support nested trees', target_format)
526
def get_format_string(self):
527
"""See RepositoryFormat.get_format_string()."""
528
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
530
def get_format_description(self):
531
"""See RepositoryFormat.get_format_description()."""
532
return "Knit repository format 3"
535
class RepositoryFormatKnit4(RepositoryFormatKnit):
536
"""Bzr repository knit format 4.
538
This repository format has everything in format 3, except for
540
- knits for file texts and inventory
541
- hash subdirectory based stores.
542
- knits for revisions and signatures
543
- TextStores for revisions and signatures.
544
- a format marker of its own
545
- an optional 'shared-storage' flag
546
- an optional 'no-working-trees' flag
548
- support for recording full info about the tree root
551
repository_class = KnitRepository
552
_commit_builder_class = RootCommitBuilder
553
rich_root_data = True
554
supports_tree_reference = False
555
_serializer = xml6.serializer_v6
557
def _get_matching_bzrdir(self):
558
return bzrdir.format_registry.make_bzrdir('rich-root')
560
def _ignore_setting_bzrdir(self, format):
563
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
565
def check_conversion_target(self, target_format):
566
if not target_format.rich_root_data:
567
raise errors.BadConversionTarget(
568
'Does not support rich root data.', target_format)
570
def get_format_string(self):
571
"""See RepositoryFormat.get_format_string()."""
572
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
574
def get_format_description(self):
575
"""See RepositoryFormat.get_format_description()."""
576
return "Knit repository format 4"
579
def _get_stream_as_bytes(knit, required_versions):
580
"""Generate a serialised data stream.
582
The format is a bencoding of a list. The first element of the list is a
583
string of the format signature, then each subsequent element is a list
584
corresponding to a record. Those lists contain:
591
:returns: a bencoded list.
593
knit_stream = knit.get_data_stream(required_versions)
594
format_signature, data_list, callable = knit_stream
596
data.append(format_signature)
597
for version, options, length, parents in data_list:
598
data.append([version, options, parents, callable(length)])
599
return bencode.bencode(data)
added
removed
bzrlib/repofmt/knitrepo.py
