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
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]
114
def _all_revision_ids(self):
115
"""See Repository.all_revision_ids()."""
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)
193
def get_revision(self, revision_id):
194
"""Return the Revision object for a named revision"""
195
revision_id = osutils.safe_revision_id(revision_id)
196
return self.get_revision_reconcile(revision_id)
198
@symbol_versioning.deprecated_method(symbol_versioning.one_four)
200
def get_revision_graph(self, revision_id=None):
201
"""Return a dictionary containing the revision graph.
203
:param revision_id: The revision_id to get a graph from. If None, then
204
the entire revision graph is returned. This is a deprecated mode of
205
operation and will be removed in the future.
206
:return: a dictionary of revision_id->revision_parents_list.
208
if 'evil' in debug.debug_flags:
210
"get_revision_graph scales with size of history.")
211
# special case NULL_REVISION
212
if revision_id == _mod_revision.NULL_REVISION:
214
a_weave = self._get_revision_vf()
215
if revision_id is None:
216
return a_weave.get_graph()
217
if revision_id not in a_weave:
218
raise errors.NoSuchRevision(self, revision_id)
220
# add what can be reached from revision_id
221
return a_weave.get_graph([revision_id])
224
@symbol_versioning.deprecated_method(symbol_versioning.one_three)
225
def get_revision_graph_with_ghosts(self, revision_ids=None):
226
"""Return a graph of the revisions with ghosts marked as applicable.
228
:param revision_ids: an iterable of revisions to graph or None for all.
229
:return: a Graph object with the graph reachable from revision_ids.
231
if 'evil' in debug.debug_flags:
233
"get_revision_graph_with_ghosts scales with size of history.")
234
result = deprecated_graph.Graph()
235
vf = self._get_revision_vf()
236
versions = set(vf.versions())
238
pending = set(self.all_revision_ids())
241
pending = set(revision_ids)
242
# special case NULL_REVISION
243
if _mod_revision.NULL_REVISION in pending:
244
pending.remove(_mod_revision.NULL_REVISION)
245
required = set(pending)
248
revision_id = pending.pop()
249
if not revision_id in versions:
250
if revision_id in required:
251
raise errors.NoSuchRevision(self, revision_id)
253
result.add_ghost(revision_id)
254
# mark it as done so we don't try for it again.
255
done.add(revision_id)
257
parent_ids = vf.get_parents_with_ghosts(revision_id)
258
for parent_id in parent_ids:
259
# is this queued or done ?
260
if (parent_id not in pending and
261
parent_id not in done):
263
pending.add(parent_id)
264
result.add_node(revision_id, parent_ids)
265
done.add(revision_id)
268
def _get_revision_vf(self):
269
""":return: a versioned file containing the revisions."""
270
vf = self._revision_store.get_revision_file(self.get_transaction())
273
def has_revisions(self, revision_ids):
274
"""See Repository.has_revisions()."""
276
transaction = self.get_transaction()
277
for revision_id in revision_ids:
278
if self._revision_store.has_revision_id(revision_id, transaction):
279
result.add(revision_id)
283
def reconcile(self, other=None, thorough=False):
284
"""Reconcile this repository."""
285
from bzrlib.reconcile import KnitReconciler
286
reconciler = KnitReconciler(self, thorough=thorough)
287
reconciler.reconcile()
290
def revision_parents(self, revision_id):
291
return self._get_revision_vf().get_parents(revision_id)
293
def _make_parents_provider(self):
294
return _KnitParentsProvider(self._get_revision_vf())
296
def _find_inconsistent_revision_parents(self):
297
"""Find revisions with different parent lists in the revision object
298
and in the index graph.
300
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
301
parents-in-revision).
303
assert self.is_locked()
304
vf = self._get_revision_vf()
305
for index_version in vf.versions():
306
parents_according_to_index = tuple(vf.get_parents_with_ghosts(
308
revision = self.get_revision(index_version)
309
parents_according_to_revision = tuple(revision.parent_ids)
310
if parents_according_to_index != parents_according_to_revision:
311
yield (index_version, parents_according_to_index,
312
parents_according_to_revision)
314
def _check_for_inconsistent_revision_parents(self):
315
inconsistencies = list(self._find_inconsistent_revision_parents())
317
raise errors.BzrCheckError(
318
"Revision knit has inconsistent parents.")
320
def revision_graph_can_have_wrong_parents(self):
321
# The revision.kndx could potentially claim a revision has a different
322
# parent to the revision text.
326
class RepositoryFormatKnit(MetaDirRepositoryFormat):
327
"""Bzr repository knit format (generalized).
329
This repository format has:
330
- knits for file texts and inventory
331
- hash subdirectory based stores.
332
- knits for revisions and signatures
333
- TextStores for revisions and signatures.
334
- a format marker of its own
335
- an optional 'shared-storage' flag
336
- an optional 'no-working-trees' flag
340
# Set this attribute in derived classes to control the repository class
341
# created by open and initialize.
342
repository_class = None
343
# Set this attribute in derived classes to control the
344
# _commit_builder_class that the repository objects will have passed to
346
_commit_builder_class = None
347
# Set this attribute in derived clases to control the _serializer that the
348
# repository objects will have passed to their constructor.
349
_serializer = xml5.serializer_v5
350
# Knit based repositories handle ghosts reasonably well.
351
supports_ghosts = True
352
# External lookups are not supported in this format.
353
supports_external_lookups = False
355
def _get_control_store(self, repo_transport, control_files):
356
"""Return the control store for this repository."""
357
return VersionedFileStore(
360
file_mode=control_files._file_mode,
361
versionedfile_class=knit.KnitVersionedFile,
362
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
365
def _get_revision_store(self, repo_transport, control_files):
366
"""See RepositoryFormat._get_revision_store()."""
367
versioned_file_store = VersionedFileStore(
369
file_mode=control_files._file_mode,
372
versionedfile_class=knit.KnitVersionedFile,
373
versionedfile_kwargs={'delta':False,
374
'factory':knit.KnitPlainFactory(),
378
return KnitRevisionStore(versioned_file_store)
380
def _get_text_store(self, transport, control_files):
381
"""See RepositoryFormat._get_text_store()."""
382
return self._get_versioned_file_store('knits',
385
versionedfile_class=knit.KnitVersionedFile,
386
versionedfile_kwargs={
387
'create_parent_dir':True,
389
'dir_mode':control_files._dir_mode,
393
def initialize(self, a_bzrdir, shared=False):
394
"""Create a knit format 1 repository.
396
:param a_bzrdir: bzrdir to contain the new repository; must already
398
:param shared: If true the repository will be initialized as a shared
401
mutter('creating repository in %s.', a_bzrdir.transport.base)
404
utf8_files = [('format', self.get_format_string())]
406
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
407
repo_transport = a_bzrdir.get_repository_transport(None)
408
control_files = lockable_files.LockableFiles(repo_transport,
409
'lock', lockdir.LockDir)
410
control_store = self._get_control_store(repo_transport, control_files)
411
transaction = transactions.WriteTransaction()
412
# trigger a write of the inventory store.
413
control_store.get_weave_or_empty('inventory', transaction)
414
_revision_store = self._get_revision_store(repo_transport, control_files)
415
# the revision id here is irrelevant: it will not be stored, and cannot
417
_revision_store.has_revision_id('A', transaction)
418
_revision_store.get_signature_file(transaction)
419
return self.open(a_bzrdir=a_bzrdir, _found=True)
421
def open(self, a_bzrdir, _found=False, _override_transport=None):
422
"""See RepositoryFormat.open().
424
:param _override_transport: INTERNAL USE ONLY. Allows opening the
425
repository at a slightly different url
426
than normal. I.e. during 'upgrade'.
429
format = RepositoryFormat.find_format(a_bzrdir)
430
assert format.__class__ == self.__class__
431
if _override_transport is not None:
432
repo_transport = _override_transport
434
repo_transport = a_bzrdir.get_repository_transport(None)
435
control_files = lockable_files.LockableFiles(repo_transport,
436
'lock', lockdir.LockDir)
437
text_store = self._get_text_store(repo_transport, control_files)
438
control_store = self._get_control_store(repo_transport, control_files)
439
_revision_store = self._get_revision_store(repo_transport, control_files)
440
return self.repository_class(_format=self,
442
control_files=control_files,
443
_revision_store=_revision_store,
444
control_store=control_store,
445
text_store=text_store,
446
_commit_builder_class=self._commit_builder_class,
447
_serializer=self._serializer)
450
class RepositoryFormatKnit1(RepositoryFormatKnit):
451
"""Bzr repository knit format 1.
453
This repository format has:
454
- knits for file texts and inventory
455
- hash subdirectory based stores.
456
- knits for revisions and signatures
457
- TextStores for revisions and signatures.
458
- a format marker of its own
459
- an optional 'shared-storage' flag
460
- an optional 'no-working-trees' flag
463
This format was introduced in bzr 0.8.
466
repository_class = KnitRepository
467
_commit_builder_class = CommitBuilder
468
_serializer = xml5.serializer_v5
470
def __ne__(self, other):
471
return self.__class__ is not other.__class__
473
def get_format_string(self):
474
"""See RepositoryFormat.get_format_string()."""
475
return "Bazaar-NG Knit Repository Format 1"
477
def get_format_description(self):
478
"""See RepositoryFormat.get_format_description()."""
479
return "Knit repository format 1"
481
def check_conversion_target(self, target_format):
485
class RepositoryFormatKnit3(RepositoryFormatKnit):
486
"""Bzr repository knit format 3.
488
This repository format has:
489
- knits for file texts and inventory
490
- hash subdirectory based stores.
491
- knits for revisions and signatures
492
- TextStores for revisions and signatures.
493
- a format marker of its own
494
- an optional 'shared-storage' flag
495
- an optional 'no-working-trees' flag
497
- support for recording full info about the tree root
498
- support for recording tree-references
501
repository_class = KnitRepository
502
_commit_builder_class = RootCommitBuilder
503
rich_root_data = True
504
supports_tree_reference = True
505
_serializer = xml7.serializer_v7
507
def _get_matching_bzrdir(self):
508
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
510
def _ignore_setting_bzrdir(self, format):
513
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
515
def check_conversion_target(self, target_format):
516
if not target_format.rich_root_data:
517
raise errors.BadConversionTarget(
518
'Does not support rich root data.', target_format)
519
if not getattr(target_format, 'supports_tree_reference', False):
520
raise errors.BadConversionTarget(
521
'Does not support nested trees', target_format)
523
def get_format_string(self):
524
"""See RepositoryFormat.get_format_string()."""
525
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
527
def get_format_description(self):
528
"""See RepositoryFormat.get_format_description()."""
529
return "Knit repository format 3"
532
class RepositoryFormatKnit4(RepositoryFormatKnit):
533
"""Bzr repository knit format 4.
535
This repository format has everything in format 3, except for
537
- knits for file texts and inventory
538
- hash subdirectory based stores.
539
- knits for revisions and signatures
540
- TextStores for revisions and signatures.
541
- a format marker of its own
542
- an optional 'shared-storage' flag
543
- an optional 'no-working-trees' flag
545
- support for recording full info about the tree root
548
repository_class = KnitRepository
549
_commit_builder_class = RootCommitBuilder
550
rich_root_data = True
551
supports_tree_reference = False
552
_serializer = xml6.serializer_v6
554
def _get_matching_bzrdir(self):
555
return bzrdir.format_registry.make_bzrdir('rich-root')
557
def _ignore_setting_bzrdir(self, format):
560
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
562
def check_conversion_target(self, target_format):
563
if not target_format.rich_root_data:
564
raise errors.BadConversionTarget(
565
'Does not support rich root data.', target_format)
567
def get_format_string(self):
568
"""See RepositoryFormat.get_format_string()."""
569
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
571
def get_format_description(self):
572
"""See RepositoryFormat.get_format_description()."""
573
return "Knit repository format 4"
576
def _get_stream_as_bytes(knit, required_versions):
577
"""Generate a serialised data stream.
579
The format is a bencoding of a list. The first element of the list is a
580
string of the format signature, then each subsequent element is a list
581
corresponding to a record. Those lists contain:
588
:returns: a bencoded list.
590
knit_stream = knit.get_data_stream(required_versions)
591
format_signature, data_list, callable = knit_stream
593
data.append(format_signature)
594
for version, options, length, parents in data_list:
595
data.append([version, options, parents, callable(length)])
596
return bencode.bencode(data)
added
removed
bzrlib/repofmt/knitrepo.py
