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)
164
def get_data_stream(self, revision_ids):
165
"""See Repository.get_data_stream.
167
Deprecated in 1.2 for get_data_stream_for_search.
169
search_result = self.revision_ids_to_search_result(set(revision_ids))
170
return self.get_data_stream_for_search(search_result)
172
def get_data_stream_for_search(self, search):
173
"""See Repository.get_data_stream_for_search."""
174
item_keys = self.item_keys_introduced_by(search.get_keys())
175
for knit_kind, file_id, versions in item_keys:
177
if knit_kind == 'file':
178
name = ('file', file_id)
179
knit = self.weave_store.get_weave_or_empty(
180
file_id, self.get_transaction())
181
elif knit_kind == 'inventory':
182
knit = self.get_inventory_weave()
183
elif knit_kind == 'revisions':
184
knit = self._revision_store.get_revision_file(
185
self.get_transaction())
186
elif knit_kind == 'signatures':
187
knit = self._revision_store.get_signature_file(
188
self.get_transaction())
190
raise AssertionError('Unknown knit kind %r' % (knit_kind,))
191
yield name, _get_stream_as_bytes(knit, versions)
194
def get_revision(self, revision_id):
195
"""Return the Revision object for a named revision"""
196
revision_id = osutils.safe_revision_id(revision_id)
197
return self.get_revision_reconcile(revision_id)
199
@symbol_versioning.deprecated_method(symbol_versioning.one_four)
201
def get_revision_graph(self, revision_id=None):
202
"""Return a dictionary containing the revision graph.
204
:param revision_id: The revision_id to get a graph from. If None, then
205
the entire revision graph is returned. This is a deprecated mode of
206
operation and will be removed in the future.
207
:return: a dictionary of revision_id->revision_parents_list.
209
if 'evil' in debug.debug_flags:
211
"get_revision_graph scales with size of history.")
212
# special case NULL_REVISION
213
if revision_id == _mod_revision.NULL_REVISION:
215
a_weave = self._get_revision_vf()
216
if revision_id is None:
217
return a_weave.get_graph()
218
if revision_id not in a_weave:
219
raise errors.NoSuchRevision(self, revision_id)
221
# add what can be reached from revision_id
222
return a_weave.get_graph([revision_id])
225
@symbol_versioning.deprecated_method(symbol_versioning.one_three)
226
def get_revision_graph_with_ghosts(self, revision_ids=None):
227
"""Return a graph of the revisions with ghosts marked as applicable.
229
:param revision_ids: an iterable of revisions to graph or None for all.
230
:return: a Graph object with the graph reachable from revision_ids.
232
if 'evil' in debug.debug_flags:
234
"get_revision_graph_with_ghosts scales with size of history.")
235
result = deprecated_graph.Graph()
236
vf = self._get_revision_vf()
237
versions = set(vf.versions())
239
pending = set(self.all_revision_ids())
242
pending = set(revision_ids)
243
# special case NULL_REVISION
244
if _mod_revision.NULL_REVISION in pending:
245
pending.remove(_mod_revision.NULL_REVISION)
246
required = set(pending)
249
revision_id = pending.pop()
250
if not revision_id in versions:
251
if revision_id in required:
252
raise errors.NoSuchRevision(self, revision_id)
254
result.add_ghost(revision_id)
255
# mark it as done so we don't try for it again.
256
done.add(revision_id)
258
parent_ids = vf.get_parents_with_ghosts(revision_id)
259
for parent_id in parent_ids:
260
# is this queued or done ?
261
if (parent_id not in pending and
262
parent_id not in done):
264
pending.add(parent_id)
265
result.add_node(revision_id, parent_ids)
266
done.add(revision_id)
269
def _get_revision_vf(self):
270
""":return: a versioned file containing the revisions."""
271
vf = self._revision_store.get_revision_file(self.get_transaction())
274
def has_revisions(self, revision_ids):
275
"""See Repository.has_revisions()."""
277
transaction = self.get_transaction()
278
for revision_id in revision_ids:
279
if self._revision_store.has_revision_id(revision_id, transaction):
280
result.add(revision_id)
284
def reconcile(self, other=None, thorough=False):
285
"""Reconcile this repository."""
286
from bzrlib.reconcile import KnitReconciler
287
reconciler = KnitReconciler(self, thorough=thorough)
288
reconciler.reconcile()
291
def revision_parents(self, revision_id):
292
return self._get_revision_vf().get_parents(revision_id)
294
def _make_parents_provider(self):
295
return _KnitParentsProvider(self._get_revision_vf())
297
def _find_inconsistent_revision_parents(self):
298
"""Find revisions with different parent lists in the revision object
299
and in the index graph.
301
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
302
parents-in-revision).
304
assert self.is_locked()
305
vf = self._get_revision_vf()
306
for index_version in vf.versions():
307
parents_according_to_index = tuple(vf.get_parents_with_ghosts(
309
revision = self.get_revision(index_version)
310
parents_according_to_revision = tuple(revision.parent_ids)
311
if parents_according_to_index != parents_according_to_revision:
312
yield (index_version, parents_according_to_index,
313
parents_according_to_revision)
315
def _check_for_inconsistent_revision_parents(self):
316
inconsistencies = list(self._find_inconsistent_revision_parents())
318
raise errors.BzrCheckError(
319
"Revision knit has inconsistent parents.")
321
def revision_graph_can_have_wrong_parents(self):
322
# The revision.kndx could potentially claim a revision has a different
323
# parent to the revision text.
327
class RepositoryFormatKnit(MetaDirRepositoryFormat):
328
"""Bzr repository knit format (generalized).
330
This repository format has:
331
- knits for file texts and inventory
332
- hash subdirectory based stores.
333
- knits for revisions and signatures
334
- TextStores for revisions and signatures.
335
- a format marker of its own
336
- an optional 'shared-storage' flag
337
- an optional 'no-working-trees' flag
341
# Set this attribute in derived classes to control the repository class
342
# created by open and initialize.
343
repository_class = None
344
# Set this attribute in derived classes to control the
345
# _commit_builder_class that the repository objects will have passed to
347
_commit_builder_class = None
348
# Set this attribute in derived clases to control the _serializer that the
349
# repository objects will have passed to their constructor.
350
_serializer = xml5.serializer_v5
351
# Knit based repositories handle ghosts reasonably well.
352
supports_ghosts = True
353
# External lookups are not supported in this format.
354
supports_external_lookups = False
356
def _get_control_store(self, repo_transport, control_files):
357
"""Return the control store for this repository."""
358
return VersionedFileStore(
361
file_mode=control_files._file_mode,
362
versionedfile_class=knit.make_file_knit,
363
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
366
def _get_revision_store(self, repo_transport, control_files):
367
"""See RepositoryFormat._get_revision_store()."""
368
versioned_file_store = VersionedFileStore(
370
file_mode=control_files._file_mode,
373
versionedfile_class=knit.make_file_knit,
374
versionedfile_kwargs={'delta':False,
375
'factory':knit.KnitPlainFactory(),
379
return KnitRevisionStore(versioned_file_store)
381
def _get_text_store(self, transport, control_files):
382
"""See RepositoryFormat._get_text_store()."""
383
return self._get_versioned_file_store('knits',
386
versionedfile_class=knit.make_file_knit,
387
versionedfile_kwargs={
388
'create_parent_dir':True,
390
'dir_mode':control_files._dir_mode,
394
def initialize(self, a_bzrdir, shared=False):
395
"""Create a knit format 1 repository.
397
:param a_bzrdir: bzrdir to contain the new repository; must already
399
:param shared: If true the repository will be initialized as a shared
402
mutter('creating repository in %s.', a_bzrdir.transport.base)
405
utf8_files = [('format', self.get_format_string())]
407
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
408
repo_transport = a_bzrdir.get_repository_transport(None)
409
control_files = lockable_files.LockableFiles(repo_transport,
410
'lock', lockdir.LockDir)
411
control_store = self._get_control_store(repo_transport, control_files)
412
transaction = transactions.WriteTransaction()
413
# trigger a write of the inventory store.
414
control_store.get_weave_or_empty('inventory', transaction)
415
_revision_store = self._get_revision_store(repo_transport, control_files)
416
# the revision id here is irrelevant: it will not be stored, and cannot
418
_revision_store.has_revision_id('A', transaction)
419
_revision_store.get_signature_file(transaction)
420
return self.open(a_bzrdir=a_bzrdir, _found=True)
422
def open(self, a_bzrdir, _found=False, _override_transport=None):
423
"""See RepositoryFormat.open().
425
:param _override_transport: INTERNAL USE ONLY. Allows opening the
426
repository at a slightly different url
427
than normal. I.e. during 'upgrade'.
430
format = RepositoryFormat.find_format(a_bzrdir)
431
assert format.__class__ == self.__class__
432
if _override_transport is not None:
433
repo_transport = _override_transport
435
repo_transport = a_bzrdir.get_repository_transport(None)
436
control_files = lockable_files.LockableFiles(repo_transport,
437
'lock', lockdir.LockDir)
438
text_store = self._get_text_store(repo_transport, control_files)
439
control_store = self._get_control_store(repo_transport, control_files)
440
_revision_store = self._get_revision_store(repo_transport, control_files)
441
return self.repository_class(_format=self,
443
control_files=control_files,
444
_revision_store=_revision_store,
445
control_store=control_store,
446
text_store=text_store,
447
_commit_builder_class=self._commit_builder_class,
448
_serializer=self._serializer)
451
class RepositoryFormatKnit1(RepositoryFormatKnit):
452
"""Bzr repository knit format 1.
454
This repository format has:
455
- knits for file texts and inventory
456
- hash subdirectory based stores.
457
- knits for revisions and signatures
458
- TextStores for revisions and signatures.
459
- a format marker of its own
460
- an optional 'shared-storage' flag
461
- an optional 'no-working-trees' flag
464
This format was introduced in bzr 0.8.
467
repository_class = KnitRepository
468
_commit_builder_class = CommitBuilder
469
_serializer = xml5.serializer_v5
471
def __ne__(self, other):
472
return self.__class__ is not other.__class__
474
def get_format_string(self):
475
"""See RepositoryFormat.get_format_string()."""
476
return "Bazaar-NG Knit Repository Format 1"
478
def get_format_description(self):
479
"""See RepositoryFormat.get_format_description()."""
480
return "Knit repository format 1"
482
def check_conversion_target(self, target_format):
486
class RepositoryFormatKnit3(RepositoryFormatKnit):
487
"""Bzr repository knit format 3.
489
This repository format has:
490
- knits for file texts and inventory
491
- hash subdirectory based stores.
492
- knits for revisions and signatures
493
- TextStores for revisions and signatures.
494
- a format marker of its own
495
- an optional 'shared-storage' flag
496
- an optional 'no-working-trees' flag
498
- support for recording full info about the tree root
499
- support for recording tree-references
502
repository_class = KnitRepository
503
_commit_builder_class = RootCommitBuilder
504
rich_root_data = True
505
supports_tree_reference = True
506
_serializer = xml7.serializer_v7
508
def _get_matching_bzrdir(self):
509
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
511
def _ignore_setting_bzrdir(self, format):
514
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
516
def check_conversion_target(self, target_format):
517
if not target_format.rich_root_data:
518
raise errors.BadConversionTarget(
519
'Does not support rich root data.', target_format)
520
if not getattr(target_format, 'supports_tree_reference', False):
521
raise errors.BadConversionTarget(
522
'Does not support nested trees', target_format)
524
def get_format_string(self):
525
"""See RepositoryFormat.get_format_string()."""
526
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
528
def get_format_description(self):
529
"""See RepositoryFormat.get_format_description()."""
530
return "Knit repository format 3"
533
class RepositoryFormatKnit4(RepositoryFormatKnit):
534
"""Bzr repository knit format 4.
536
This repository format has everything in format 3, except for
538
- knits for file texts and inventory
539
- hash subdirectory based stores.
540
- knits for revisions and signatures
541
- TextStores for revisions and signatures.
542
- a format marker of its own
543
- an optional 'shared-storage' flag
544
- an optional 'no-working-trees' flag
546
- support for recording full info about the tree root
549
repository_class = KnitRepository
550
_commit_builder_class = RootCommitBuilder
551
rich_root_data = True
552
supports_tree_reference = False
553
_serializer = xml6.serializer_v6
555
def _get_matching_bzrdir(self):
556
return bzrdir.format_registry.make_bzrdir('rich-root')
558
def _ignore_setting_bzrdir(self, format):
561
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
563
def check_conversion_target(self, target_format):
564
if not target_format.rich_root_data:
565
raise errors.BadConversionTarget(
566
'Does not support rich root data.', target_format)
568
def get_format_string(self):
569
"""See RepositoryFormat.get_format_string()."""
570
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
572
def get_format_description(self):
573
"""See RepositoryFormat.get_format_description()."""
574
return "Knit repository format 4"
577
def _get_stream_as_bytes(knit, required_versions):
578
"""Generate a serialised data stream.
580
The format is a bencoding of a list. The first element of the list is a
581
string of the format signature, then each subsequent element is a list
582
corresponding to a record. Those lists contain:
589
:returns: a bencoded list.
591
knit_stream = knit.get_data_stream(required_versions)
592
format_signature, data_list, callable = knit_stream
594
data.append(format_signature)
595
for version, options, length, parents in data_list:
596
data.append([version, options, parents, callable(length)])
597
return bencode.bencode(data)
added
removed
bzrlib/repofmt/knitrepo.py
