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(), """
26
revision as _mod_revision,
37
from bzrlib.decorators import needs_read_lock, needs_write_lock
38
from bzrlib.repository import (
41
MetaDirRepositoryFormat,
45
from bzrlib.trace import mutter, mutter_callsite
48
class _KnitParentsProvider(object):
50
def __init__(self, knit):
54
return 'KnitParentsProvider(%r)' % self._knit
56
@symbol_versioning.deprecated_method(symbol_versioning.one_one)
57
def get_parents(self, revision_ids):
58
"""See graph._StackedParentsProvider.get_parents"""
59
parent_map = self.get_parent_map(revision_ids)
60
return [parent_map.get(r, None) for r in revision_ids]
62
def get_parent_map(self, keys):
63
"""See graph._StackedParentsProvider.get_parent_map"""
65
for revision_id in keys:
66
if revision_id is None:
67
raise ValueError('get_parent_map(None) is not valid')
68
if revision_id == _mod_revision.NULL_REVISION:
69
parent_map[revision_id] = ()
73
self._knit.get_parents_with_ghosts(revision_id))
74
except errors.RevisionNotPresent:
78
parents = (_mod_revision.NULL_REVISION,)
79
parent_map[revision_id] = parents
83
class _KnitsParentsProvider(object):
85
def __init__(self, knit, prefix=()):
86
"""Create a parent provider for string keys mapped to tuple keys."""
91
return 'KnitsParentsProvider(%r)' % self._knit
93
def get_parent_map(self, keys):
94
"""See graph._StackedParentsProvider.get_parent_map"""
95
parent_map = self._knit.get_parent_map(
96
[self._prefix + (key,) for key in keys])
98
for key, parents in parent_map.items():
100
if len(parents) == 0:
101
parents = (_mod_revision.NULL_REVISION,)
103
parents = tuple(parent[-1] for parent in parents)
104
result[revid] = parents
105
for revision_id in keys:
106
if revision_id == _mod_revision.NULL_REVISION:
107
result[revision_id] = ()
111
class KnitRepository(MetaDirRepository):
112
"""Knit format repository."""
114
# These attributes are inherited from the Repository base class. Setting
115
# them to None ensures that if the constructor is changed to not initialize
116
# them, or a subclass fails to call the constructor, that an error will
117
# occur rather than the system working but generating incorrect data.
118
_commit_builder_class = None
121
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
123
MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
124
self._commit_builder_class = _commit_builder_class
125
self._serializer = _serializer
126
self._reconcile_fixes_text_parents = True
127
self._fetch_uses_deltas = True
128
self._fetch_order = 'topological'
131
def _all_revision_ids(self):
132
"""See Repository.all_revision_ids()."""
133
return [key[0] for key in self.revisions.keys()]
135
def _activate_new_inventory(self):
136
"""Put a replacement inventory.new into use as inventories."""
137
# Copy the content across
139
t.copy('inventory.new.kndx', 'inventory.kndx')
141
t.copy('inventory.new.knit', 'inventory.knit')
142
except errors.NoSuchFile:
143
# empty inventories knit
144
t.delete('inventory.knit')
145
# delete the temp inventory
146
t.delete('inventory.new.kndx')
148
t.delete('inventory.new.knit')
149
except errors.NoSuchFile:
150
# empty inventories knit
152
# Force index reload (sanity check)
153
self.inventories._index._reset_cache()
154
self.inventories.keys()
156
def _backup_inventory(self):
158
t.copy('inventory.kndx', 'inventory.backup.kndx')
159
t.copy('inventory.knit', 'inventory.backup.knit')
161
def _move_file_id(self, from_id, to_id):
162
t = self._transport.clone('knits')
163
from_rel_url = self.texts._index._mapper.map((from_id, None))
164
to_rel_url = self.texts._index._mapper.map((to_id, None))
165
# We expect both files to always exist in this case.
166
for suffix in ('.knit', '.kndx'):
167
t.rename(from_rel_url + suffix, to_rel_url + suffix)
169
def _remove_file_id(self, file_id):
170
t = self._transport.clone('knits')
171
rel_url = self.texts._index._mapper.map((file_id, None))
172
for suffix in ('.kndx', '.knit'):
174
t.delete(rel_url + suffix)
175
except errors.NoSuchFile:
178
def _temp_inventories(self):
179
result = self._format._get_inventories(self._transport, self,
181
# Reconciling when the output has no revisions would result in no
182
# writes - but we want to ensure there is an inventory for
183
# compatibility with older clients that don't lazy-load.
184
result.get_parent_map([('A',)])
187
def fileid_involved_between_revs(self, from_revid, to_revid):
188
"""Find file_id(s) which are involved in the changes between revisions.
190
This determines the set of revisions which are involved, and then
191
finds all file ids affected by those revisions.
193
vf = self._get_revision_vf()
194
from_set = set(vf.get_ancestry(from_revid))
195
to_set = set(vf.get_ancestry(to_revid))
196
changed = to_set.difference(from_set)
197
return self._fileid_involved_by_set(changed)
199
def fileid_involved(self, last_revid=None):
200
"""Find all file_ids modified in the ancestry of last_revid.
202
:param last_revid: If None, last_revision() will be used.
205
changed = set(self.all_revision_ids())
207
changed = set(self.get_ancestry(last_revid))
210
return self._fileid_involved_by_set(changed)
213
def get_revision(self, revision_id):
214
"""Return the Revision object for a named revision"""
215
revision_id = osutils.safe_revision_id(revision_id)
216
return self.get_revision_reconcile(revision_id)
219
def reconcile(self, other=None, thorough=False):
220
"""Reconcile this repository."""
221
from bzrlib.reconcile import KnitReconciler
222
reconciler = KnitReconciler(self, thorough=thorough)
223
reconciler.reconcile()
226
def _make_parents_provider(self):
227
return _KnitsParentsProvider(self.revisions)
229
def _find_inconsistent_revision_parents(self):
230
"""Find revisions with different parent lists in the revision object
231
and in the index graph.
233
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
234
parents-in-revision).
236
if not self.is_locked():
237
raise AssertionError()
239
for index_version in vf.keys():
240
parent_map = vf.get_parent_map([index_version])
241
parents_according_to_index = tuple(parent[-1] for parent in
242
parent_map[index_version])
243
revision = self.get_revision(index_version[-1])
244
parents_according_to_revision = tuple(revision.parent_ids)
245
if parents_according_to_index != parents_according_to_revision:
246
yield (index_version[-1], parents_according_to_index,
247
parents_according_to_revision)
249
def _check_for_inconsistent_revision_parents(self):
250
inconsistencies = list(self._find_inconsistent_revision_parents())
252
raise errors.BzrCheckError(
253
"Revision knit has inconsistent parents.")
255
def revision_graph_can_have_wrong_parents(self):
256
# The revision.kndx could potentially claim a revision has a different
257
# parent to the revision text.
261
class RepositoryFormatKnit(MetaDirRepositoryFormat):
262
"""Bzr repository knit format (generalized).
264
This repository format has:
265
- knits for file texts and inventory
266
- hash subdirectory based stores.
267
- knits for revisions and signatures
268
- TextStores for revisions and signatures.
269
- a format marker of its own
270
- an optional 'shared-storage' flag
271
- an optional 'no-working-trees' flag
275
# Set this attribute in derived classes to control the repository class
276
# created by open and initialize.
277
repository_class = None
278
# Set this attribute in derived classes to control the
279
# _commit_builder_class that the repository objects will have passed to
281
_commit_builder_class = None
282
# Set this attribute in derived clases to control the _serializer that the
283
# repository objects will have passed to their constructor.
285
def _serializer(self):
286
return xml5.serializer_v5
287
# Knit based repositories handle ghosts reasonably well.
288
supports_ghosts = True
289
# External lookups are not supported in this format.
290
supports_external_lookups = False
292
def _get_inventories(self, repo_transport, repo, name='inventory'):
293
mapper = versionedfile.ConstantMapper(name)
294
index = _mod_knit._KndxIndex(repo_transport, mapper,
295
repo.get_transaction, repo.is_write_locked, repo.is_locked)
296
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
297
return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
299
def _get_revisions(self, repo_transport, repo):
300
mapper = versionedfile.ConstantMapper('revisions')
301
index = _mod_knit._KndxIndex(repo_transport, mapper,
302
repo.get_transaction, repo.is_write_locked, repo.is_locked)
303
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
304
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
307
def _get_signatures(self, repo_transport, repo):
308
mapper = versionedfile.ConstantMapper('signatures')
309
index = _mod_knit._KndxIndex(repo_transport, mapper,
310
repo.get_transaction, repo.is_write_locked, repo.is_locked)
311
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
312
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
315
def _get_texts(self, repo_transport, repo):
316
mapper = versionedfile.HashEscapedPrefixMapper()
317
base_transport = repo_transport.clone('knits')
318
index = _mod_knit._KndxIndex(base_transport, mapper,
319
repo.get_transaction, repo.is_write_locked, repo.is_locked)
320
access = _mod_knit._KnitKeyAccess(base_transport, mapper)
321
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
324
def initialize(self, a_bzrdir, shared=False):
325
"""Create a knit format 1 repository.
327
:param a_bzrdir: bzrdir to contain the new repository; must already
329
:param shared: If true the repository will be initialized as a shared
332
mutter('creating repository in %s.', a_bzrdir.transport.base)
335
utf8_files = [('format', self.get_format_string())]
337
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
338
repo_transport = a_bzrdir.get_repository_transport(None)
339
control_files = lockable_files.LockableFiles(repo_transport,
340
'lock', lockdir.LockDir)
341
transaction = transactions.WriteTransaction()
342
result = self.open(a_bzrdir=a_bzrdir, _found=True)
344
# the revision id here is irrelevant: it will not be stored, and cannot
345
# already exist, we do this to create files on disk for older clients.
346
result.inventories.get_parent_map([('A',)])
347
result.revisions.get_parent_map([('A',)])
348
result.signatures.get_parent_map([('A',)])
352
def open(self, a_bzrdir, _found=False, _override_transport=None):
353
"""See RepositoryFormat.open().
355
:param _override_transport: INTERNAL USE ONLY. Allows opening the
356
repository at a slightly different url
357
than normal. I.e. during 'upgrade'.
360
format = RepositoryFormat.find_format(a_bzrdir)
361
if _override_transport is not None:
362
repo_transport = _override_transport
364
repo_transport = a_bzrdir.get_repository_transport(None)
365
control_files = lockable_files.LockableFiles(repo_transport,
366
'lock', lockdir.LockDir)
367
repo = self.repository_class(_format=self,
369
control_files=control_files,
370
_commit_builder_class=self._commit_builder_class,
371
_serializer=self._serializer)
372
repo.revisions = self._get_revisions(repo_transport, repo)
373
repo.signatures = self._get_signatures(repo_transport, repo)
374
repo.inventories = self._get_inventories(repo_transport, repo)
375
repo.texts = self._get_texts(repo_transport, repo)
376
repo._transport = repo_transport
380
class RepositoryFormatKnit1(RepositoryFormatKnit):
381
"""Bzr repository knit format 1.
383
This repository format has:
384
- knits for file texts and inventory
385
- hash subdirectory based stores.
386
- knits for revisions and signatures
387
- TextStores for revisions and signatures.
388
- a format marker of its own
389
- an optional 'shared-storage' flag
390
- an optional 'no-working-trees' flag
393
This format was introduced in bzr 0.8.
396
repository_class = KnitRepository
397
_commit_builder_class = CommitBuilder
399
def _serializer(self):
400
return xml5.serializer_v5
402
def __ne__(self, other):
403
return self.__class__ is not other.__class__
405
def get_format_string(self):
406
"""See RepositoryFormat.get_format_string()."""
407
return "Bazaar-NG Knit Repository Format 1"
409
def get_format_description(self):
410
"""See RepositoryFormat.get_format_description()."""
411
return "Knit repository format 1"
413
def check_conversion_target(self, target_format):
417
class RepositoryFormatKnit3(RepositoryFormatKnit):
418
"""Bzr repository knit format 3.
420
This repository format has:
421
- knits for file texts and inventory
422
- hash subdirectory based stores.
423
- knits for revisions and signatures
424
- TextStores for revisions and signatures.
425
- a format marker of its own
426
- an optional 'shared-storage' flag
427
- an optional 'no-working-trees' flag
429
- support for recording full info about the tree root
430
- support for recording tree-references
433
repository_class = KnitRepository
434
_commit_builder_class = RootCommitBuilder
435
rich_root_data = True
436
supports_tree_reference = True
438
def _serializer(self):
439
return xml7.serializer_v7
441
def _get_matching_bzrdir(self):
442
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
444
def _ignore_setting_bzrdir(self, format):
447
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
449
def check_conversion_target(self, target_format):
450
if not target_format.rich_root_data:
451
raise errors.BadConversionTarget(
452
'Does not support rich root data.', target_format)
453
if not getattr(target_format, 'supports_tree_reference', False):
454
raise errors.BadConversionTarget(
455
'Does not support nested trees', target_format)
457
def get_format_string(self):
458
"""See RepositoryFormat.get_format_string()."""
459
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
461
def get_format_description(self):
462
"""See RepositoryFormat.get_format_description()."""
463
return "Knit repository format 3"
466
class RepositoryFormatKnit4(RepositoryFormatKnit):
467
"""Bzr repository knit format 4.
469
This repository format has everything in format 3, except for
471
- knits for file texts and inventory
472
- hash subdirectory based stores.
473
- knits for revisions and signatures
474
- TextStores for revisions and signatures.
475
- a format marker of its own
476
- an optional 'shared-storage' flag
477
- an optional 'no-working-trees' flag
479
- support for recording full info about the tree root
482
repository_class = KnitRepository
483
_commit_builder_class = RootCommitBuilder
484
rich_root_data = True
485
supports_tree_reference = False
487
def _serializer(self):
488
return xml6.serializer_v6
490
def _get_matching_bzrdir(self):
491
return bzrdir.format_registry.make_bzrdir('rich-root')
493
def _ignore_setting_bzrdir(self, format):
496
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
498
def check_conversion_target(self, target_format):
499
if not target_format.rich_root_data:
500
raise errors.BadConversionTarget(
501
'Does not support rich root data.', target_format)
503
def get_format_string(self):
504
"""See RepositoryFormat.get_format_string()."""
505
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
507
def get_format_description(self):
508
"""See RepositoryFormat.get_format_description()."""
509
return "Knit repository format 4"
added
removed
bzrlib/repofmt/knitrepo.py
