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
39
from bzrlib.decorators import needs_read_lock, needs_write_lock
40
from bzrlib.repository import (
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
53
class _KnitParentsProvider(object):
55
def __init__(self, knit):
59
return 'KnitParentsProvider(%r)' % self._knit
61
def get_parents(self, revision_ids):
63
for revision_id in revision_ids:
64
if revision_id == _mod_revision.NULL_REVISION:
68
parents = self._knit.get_parents_with_ghosts(revision_id)
69
except errors.RevisionNotPresent:
73
parents = [_mod_revision.NULL_REVISION]
74
parents_list.append(parents)
78
class KnitRepository(MetaDirRepository):
79
"""Knit format repository."""
81
# These attributes are inherited from the Repository base class. Setting
82
# them to None ensures that if the constructor is changed to not initialize
83
# them, or a subclass fails to call the constructor, that an error will
84
# occur rather than the system working but generating incorrect data.
85
_commit_builder_class = None
88
def __init__(self, _format, a_bzrdir, control_files, _revision_store,
89
control_store, text_store, _commit_builder_class, _serializer):
90
MetaDirRepository.__init__(self, _format, a_bzrdir, control_files,
91
_revision_store, control_store, text_store)
92
self._commit_builder_class = _commit_builder_class
93
self._serializer = _serializer
94
self._reconcile_fixes_text_parents = True
96
def _warn_if_deprecated(self):
97
# This class isn't deprecated
100
def _inventory_add_lines(self, inv_vf, revid, parents, lines, check_content):
101
return inv_vf.add_lines_with_ghosts(revid, parents, lines,
102
check_content=check_content)[0]
105
def _all_revision_ids(self):
106
"""See Repository.all_revision_ids()."""
107
# Knits get the revision graph from the index of the revision knit, so
108
# it's always possible even if they're on an unlistable transport.
109
return self._revision_store.all_revision_ids(self.get_transaction())
111
def fileid_involved_between_revs(self, from_revid, to_revid):
112
"""Find file_id(s) which are involved in the changes between revisions.
114
This determines the set of revisions which are involved, and then
115
finds all file ids affected by those revisions.
117
vf = self._get_revision_vf()
118
from_set = set(vf.get_ancestry(from_revid))
119
to_set = set(vf.get_ancestry(to_revid))
120
changed = to_set.difference(from_set)
121
return self._fileid_involved_by_set(changed)
123
def fileid_involved(self, last_revid=None):
124
"""Find all file_ids modified in the ancestry of last_revid.
126
:param last_revid: If None, last_revision() will be used.
129
changed = set(self.all_revision_ids())
131
changed = set(self.get_ancestry(last_revid))
134
return self._fileid_involved_by_set(changed)
137
def get_ancestry(self, revision_id, topo_sorted=True):
138
"""Return a list of revision-ids integrated by a revision.
140
This is topologically sorted, unless 'topo_sorted' is specified as
143
if _mod_revision.is_null(revision_id):
145
vf = self._get_revision_vf()
147
return [None] + vf.get_ancestry(revision_id, topo_sorted)
148
except errors.RevisionNotPresent:
149
raise errors.NoSuchRevision(self, revision_id)
152
def get_data_stream(self, revision_ids):
153
"""See Repository.get_data_stream."""
154
item_keys = self.item_keys_introduced_by(revision_ids)
155
for knit_kind, file_id, versions in item_keys:
157
if knit_kind == 'file':
158
name = ('file', file_id)
159
knit = self.weave_store.get_weave_or_empty(
160
file_id, self.get_transaction())
161
elif knit_kind == 'inventory':
162
knit = self.get_inventory_weave()
163
elif knit_kind == 'revisions':
164
knit = self._revision_store.get_revision_file(
165
self.get_transaction())
166
elif knit_kind == 'signatures':
167
knit = self._revision_store.get_signature_file(
168
self.get_transaction())
170
raise AssertionError('Unknown knit kind %r' % (knit_kind,))
171
yield name, _get_stream_as_bytes(knit, versions)
174
def get_revision(self, revision_id):
175
"""Return the Revision object for a named revision"""
176
revision_id = osutils.safe_revision_id(revision_id)
177
return self.get_revision_reconcile(revision_id)
180
def get_revision_graph(self, revision_id=None):
181
"""Return a dictionary containing the revision graph.
183
:param revision_id: The revision_id to get a graph from. If None, then
184
the entire revision graph is returned. This is a deprecated mode of
185
operation and will be removed in the future.
186
:return: a dictionary of revision_id->revision_parents_list.
188
if 'evil' in debug.debug_flags:
190
"get_revision_graph scales with size of history.")
191
# special case NULL_REVISION
192
if revision_id == _mod_revision.NULL_REVISION:
194
a_weave = self._get_revision_vf()
195
if revision_id is None:
196
return a_weave.get_graph()
197
if revision_id not in a_weave:
198
raise errors.NoSuchRevision(self, revision_id)
200
# add what can be reached from revision_id
201
return a_weave.get_graph([revision_id])
204
def get_revision_graph_with_ghosts(self, revision_ids=None):
205
"""Return a graph of the revisions with ghosts marked as applicable.
207
:param revision_ids: an iterable of revisions to graph or None for all.
208
:return: a Graph object with the graph reachable from revision_ids.
210
if 'evil' in debug.debug_flags:
212
"get_revision_graph_with_ghosts scales with size of history.")
213
result = deprecated_graph.Graph()
214
vf = self._get_revision_vf()
215
versions = set(vf.versions())
217
pending = set(self.all_revision_ids())
220
pending = set(revision_ids)
221
# special case NULL_REVISION
222
if _mod_revision.NULL_REVISION in pending:
223
pending.remove(_mod_revision.NULL_REVISION)
224
required = set(pending)
227
revision_id = pending.pop()
228
if not revision_id in versions:
229
if revision_id in required:
230
raise errors.NoSuchRevision(self, revision_id)
232
result.add_ghost(revision_id)
233
# mark it as done so we don't try for it again.
234
done.add(revision_id)
236
parent_ids = vf.get_parents_with_ghosts(revision_id)
237
for parent_id in parent_ids:
238
# is this queued or done ?
239
if (parent_id not in pending and
240
parent_id not in done):
242
pending.add(parent_id)
243
result.add_node(revision_id, parent_ids)
244
done.add(revision_id)
247
def _get_revision_vf(self):
248
""":return: a versioned file containing the revisions."""
249
vf = self._revision_store.get_revision_file(self.get_transaction())
252
def _get_history_vf(self):
253
"""Get a versionedfile whose history graph reflects all revisions.
255
For knit repositories, this is the revision knit.
257
return self._get_revision_vf()
260
def reconcile(self, other=None, thorough=False):
261
"""Reconcile this repository."""
262
from bzrlib.reconcile import KnitReconciler
263
reconciler = KnitReconciler(self, thorough=thorough)
264
reconciler.reconcile()
267
def revision_parents(self, revision_id):
268
return self._get_revision_vf().get_parents(revision_id)
270
def _make_parents_provider(self):
271
return _KnitParentsProvider(self._get_revision_vf())
273
def _find_inconsistent_revision_parents(self):
274
"""Find revisions with different parent lists in the revision object
275
and in the index graph.
277
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
278
parents-in-revision).
280
assert self.is_locked()
281
vf = self._get_revision_vf()
282
for index_version in vf.versions():
283
parents_according_to_index = tuple(vf.get_parents_with_ghosts(
285
revision = self.get_revision(index_version)
286
parents_according_to_revision = tuple(revision.parent_ids)
287
if parents_according_to_index != parents_according_to_revision:
288
yield (index_version, parents_according_to_index,
289
parents_according_to_revision)
291
def _check_for_inconsistent_revision_parents(self):
292
inconsistencies = list(self._find_inconsistent_revision_parents())
294
raise errors.BzrCheckError(
295
"Revision knit has inconsistent parents.")
297
def revision_graph_can_have_wrong_parents(self):
298
# The revision.kndx could potentially claim a revision has a different
299
# parent to the revision text.
303
class RepositoryFormatKnit(MetaDirRepositoryFormat):
304
"""Bzr repository knit format (generalized).
306
This repository format has:
307
- knits for file texts and inventory
308
- hash subdirectory based stores.
309
- knits for revisions and signatures
310
- TextStores for revisions and signatures.
311
- a format marker of its own
312
- an optional 'shared-storage' flag
313
- an optional 'no-working-trees' flag
317
# Set this attribute in derived classes to control the repository class
318
# created by open and initialize.
319
repository_class = None
320
# Set this attribute in derived classes to control the
321
# _commit_builder_class that the repository objects will have passed to
323
_commit_builder_class = None
324
# Set this attribute in derived clases to control the _serializer that the
325
# repository objects will have passed to their constructor.
326
_serializer = xml5.serializer_v5
327
# Knit based repositories handle ghosts reasonably well.
328
supports_ghosts = True
330
def _get_control_store(self, repo_transport, control_files):
331
"""Return the control store for this repository."""
332
return VersionedFileStore(
335
file_mode=control_files._file_mode,
336
versionedfile_class=knit.KnitVersionedFile,
337
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
340
def _get_revision_store(self, repo_transport, control_files):
341
"""See RepositoryFormat._get_revision_store()."""
342
versioned_file_store = VersionedFileStore(
344
file_mode=control_files._file_mode,
347
versionedfile_class=knit.KnitVersionedFile,
348
versionedfile_kwargs={'delta':False,
349
'factory':knit.KnitPlainFactory(),
353
return KnitRevisionStore(versioned_file_store)
355
def _get_text_store(self, transport, control_files):
356
"""See RepositoryFormat._get_text_store()."""
357
return self._get_versioned_file_store('knits',
360
versionedfile_class=knit.KnitVersionedFile,
361
versionedfile_kwargs={
362
'create_parent_dir':True,
364
'dir_mode':control_files._dir_mode,
368
def initialize(self, a_bzrdir, shared=False):
369
"""Create a knit format 1 repository.
371
:param a_bzrdir: bzrdir to contain the new repository; must already
373
:param shared: If true the repository will be initialized as a shared
376
mutter('creating repository in %s.', a_bzrdir.transport.base)
379
utf8_files = [('format', self.get_format_string())]
381
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
382
repo_transport = a_bzrdir.get_repository_transport(None)
383
control_files = lockable_files.LockableFiles(repo_transport,
384
'lock', lockdir.LockDir)
385
control_store = self._get_control_store(repo_transport, control_files)
386
transaction = transactions.WriteTransaction()
387
# trigger a write of the inventory store.
388
control_store.get_weave_or_empty('inventory', transaction)
389
_revision_store = self._get_revision_store(repo_transport, control_files)
390
# the revision id here is irrelevant: it will not be stored, and cannot
392
_revision_store.has_revision_id('A', transaction)
393
_revision_store.get_signature_file(transaction)
394
return self.open(a_bzrdir=a_bzrdir, _found=True)
396
def open(self, a_bzrdir, _found=False, _override_transport=None):
397
"""See RepositoryFormat.open().
399
:param _override_transport: INTERNAL USE ONLY. Allows opening the
400
repository at a slightly different url
401
than normal. I.e. during 'upgrade'.
404
format = RepositoryFormat.find_format(a_bzrdir)
405
assert format.__class__ == self.__class__
406
if _override_transport is not None:
407
repo_transport = _override_transport
409
repo_transport = a_bzrdir.get_repository_transport(None)
410
control_files = lockable_files.LockableFiles(repo_transport,
411
'lock', lockdir.LockDir)
412
text_store = self._get_text_store(repo_transport, control_files)
413
control_store = self._get_control_store(repo_transport, control_files)
414
_revision_store = self._get_revision_store(repo_transport, control_files)
415
return self.repository_class(_format=self,
417
control_files=control_files,
418
_revision_store=_revision_store,
419
control_store=control_store,
420
text_store=text_store,
421
_commit_builder_class=self._commit_builder_class,
422
_serializer=self._serializer)
425
class RepositoryFormatKnit1(RepositoryFormatKnit):
426
"""Bzr repository knit format 1.
428
This repository format has:
429
- knits for file texts and inventory
430
- hash subdirectory based stores.
431
- knits for revisions and signatures
432
- TextStores for revisions and signatures.
433
- a format marker of its own
434
- an optional 'shared-storage' flag
435
- an optional 'no-working-trees' flag
438
This format was introduced in bzr 0.8.
441
repository_class = KnitRepository
442
_commit_builder_class = CommitBuilder
443
_serializer = xml5.serializer_v5
445
def __ne__(self, other):
446
return self.__class__ is not other.__class__
448
def get_format_string(self):
449
"""See RepositoryFormat.get_format_string()."""
450
return "Bazaar-NG Knit Repository Format 1"
452
def get_format_description(self):
453
"""See RepositoryFormat.get_format_description()."""
454
return "Knit repository format 1"
456
def check_conversion_target(self, target_format):
460
class RepositoryFormatKnit3(RepositoryFormatKnit):
461
"""Bzr repository knit format 3.
463
This repository format has:
464
- knits for file texts and inventory
465
- hash subdirectory based stores.
466
- knits for revisions and signatures
467
- TextStores for revisions and signatures.
468
- a format marker of its own
469
- an optional 'shared-storage' flag
470
- an optional 'no-working-trees' flag
472
- support for recording full info about the tree root
473
- support for recording tree-references
476
repository_class = KnitRepository
477
_commit_builder_class = RootCommitBuilder
478
rich_root_data = True
479
supports_tree_reference = True
480
_serializer = xml7.serializer_v7
482
def _get_matching_bzrdir(self):
483
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
485
def _ignore_setting_bzrdir(self, format):
488
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
490
def check_conversion_target(self, target_format):
491
if not target_format.rich_root_data:
492
raise errors.BadConversionTarget(
493
'Does not support rich root data.', target_format)
494
if not getattr(target_format, 'supports_tree_reference', False):
495
raise errors.BadConversionTarget(
496
'Does not support nested trees', target_format)
498
def get_format_string(self):
499
"""See RepositoryFormat.get_format_string()."""
500
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
502
def get_format_description(self):
503
"""See RepositoryFormat.get_format_description()."""
504
return "Knit repository format 3"
507
class RepositoryFormatKnit4(RepositoryFormatKnit):
508
"""Bzr repository knit format 4.
510
This repository format has everything in format 3, except for
512
- knits for file texts and inventory
513
- hash subdirectory based stores.
514
- knits for revisions and signatures
515
- TextStores for revisions and signatures.
516
- a format marker of its own
517
- an optional 'shared-storage' flag
518
- an optional 'no-working-trees' flag
520
- support for recording full info about the tree root
523
repository_class = KnitRepository
524
_commit_builder_class = RootCommitBuilder
525
rich_root_data = True
526
supports_tree_reference = False
527
_serializer = xml6.serializer_v6
529
def _get_matching_bzrdir(self):
530
return bzrdir.format_registry.make_bzrdir('rich-root')
532
def _ignore_setting_bzrdir(self, format):
535
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
537
def check_conversion_target(self, target_format):
538
if not target_format.rich_root_data:
539
raise errors.BadConversionTarget(
540
'Does not support rich root data.', target_format)
542
def get_format_string(self):
543
"""See RepositoryFormat.get_format_string()."""
544
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
546
def get_format_description(self):
547
"""See RepositoryFormat.get_format_description()."""
548
return "Knit repository format 4"
551
def _get_stream_as_bytes(knit, required_versions):
552
"""Generate a serialised data stream.
554
The format is a bencoding of a list. The first element of the list is a
555
string of the format signature, then each subsequent element is a list
556
corresponding to a record. Those lists contain:
563
:returns: a bencoded list.
565
knit_stream = knit.get_data_stream(required_versions)
566
format_signature, data_list, callable = knit_stream
568
data.append(format_signature)
569
for version, options, length, parents in data_list:
570
data.append([version, options, parents, callable(length)])
571
return bencode.bencode(data)
added
removed
bzrlib/repofmt/knitrepo.py
