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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
def get_parent_map(self, keys):
57
"""See graph.StackedParentsProvider.get_parent_map"""
59
for revision_id in keys:
60
if revision_id is None:
61
raise ValueError('get_parent_map(None) is not valid')
62
if revision_id == _mod_revision.NULL_REVISION:
63
parent_map[revision_id] = ()
67
self._knit.get_parents_with_ghosts(revision_id))
68
except errors.RevisionNotPresent:
72
parents = (_mod_revision.NULL_REVISION,)
73
parent_map[revision_id] = parents
77
class _KnitsParentsProvider(object):
79
def __init__(self, knit, prefix=()):
80
"""Create a parent provider for string keys mapped to tuple keys."""
85
return 'KnitsParentsProvider(%r)' % self._knit
87
def get_parent_map(self, keys):
88
"""See graph.StackedParentsProvider.get_parent_map"""
89
parent_map = self._knit.get_parent_map(
90
[self._prefix + (key,) for key in keys])
92
for key, parents in parent_map.items():
95
parents = (_mod_revision.NULL_REVISION,)
97
parents = tuple(parent[-1] for parent in parents)
98
result[revid] = parents
99
for revision_id in keys:
100
if revision_id == _mod_revision.NULL_REVISION:
101
result[revision_id] = ()
105
class KnitRepository(MetaDirRepository):
106
"""Knit format repository."""
108
# These attributes are inherited from the Repository base class. Setting
109
# them to None ensures that if the constructor is changed to not initialize
110
# them, or a subclass fails to call the constructor, that an error will
111
# occur rather than the system working but generating incorrect data.
112
_commit_builder_class = None
115
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
117
MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
118
self._commit_builder_class = _commit_builder_class
119
self._serializer = _serializer
120
self._reconcile_fixes_text_parents = True
123
def _all_revision_ids(self):
124
"""See Repository.all_revision_ids()."""
125
return [key[0] for key in self.revisions.keys()]
127
def _activate_new_inventory(self):
128
"""Put a replacement inventory.new into use as inventories."""
129
# Copy the content across
131
t.copy('inventory.new.kndx', 'inventory.kndx')
133
t.copy('inventory.new.knit', 'inventory.knit')
134
except errors.NoSuchFile:
135
# empty inventories knit
136
t.delete('inventory.knit')
137
# delete the temp inventory
138
t.delete('inventory.new.kndx')
140
t.delete('inventory.new.knit')
141
except errors.NoSuchFile:
142
# empty inventories knit
144
# Force index reload (sanity check)
145
self.inventories._index._reset_cache()
146
self.inventories.keys()
148
def _backup_inventory(self):
150
t.copy('inventory.kndx', 'inventory.backup.kndx')
151
t.copy('inventory.knit', 'inventory.backup.knit')
153
def _move_file_id(self, from_id, to_id):
154
t = self._transport.clone('knits')
155
from_rel_url = self.texts._index._mapper.map((from_id, None))
156
to_rel_url = self.texts._index._mapper.map((to_id, None))
157
# We expect both files to always exist in this case.
158
for suffix in ('.knit', '.kndx'):
159
t.rename(from_rel_url + suffix, to_rel_url + suffix)
161
def _remove_file_id(self, file_id):
162
t = self._transport.clone('knits')
163
rel_url = self.texts._index._mapper.map((file_id, None))
164
for suffix in ('.kndx', '.knit'):
166
t.delete(rel_url + suffix)
167
except errors.NoSuchFile:
170
def _temp_inventories(self):
171
result = self._format._get_inventories(self._transport, self,
173
# Reconciling when the output has no revisions would result in no
174
# writes - but we want to ensure there is an inventory for
175
# compatibility with older clients that don't lazy-load.
176
result.get_parent_map([('A',)])
179
def fileid_involved_between_revs(self, from_revid, to_revid):
180
"""Find file_id(s) which are involved in the changes between revisions.
182
This determines the set of revisions which are involved, and then
183
finds all file ids affected by those revisions.
185
vf = self._get_revision_vf()
186
from_set = set(vf.get_ancestry(from_revid))
187
to_set = set(vf.get_ancestry(to_revid))
188
changed = to_set.difference(from_set)
189
return self._fileid_involved_by_set(changed)
191
def fileid_involved(self, last_revid=None):
192
"""Find all file_ids modified in the ancestry of last_revid.
194
:param last_revid: If None, last_revision() will be used.
197
changed = set(self.all_revision_ids())
199
changed = set(self.get_ancestry(last_revid))
202
return self._fileid_involved_by_set(changed)
205
def get_revision(self, revision_id):
206
"""Return the Revision object for a named revision"""
207
revision_id = osutils.safe_revision_id(revision_id)
208
return self.get_revision_reconcile(revision_id)
210
def _refresh_data(self):
211
if not self.is_locked():
213
# Create a new transaction to force all knits to see the scope change.
214
# This is safe because we're outside a write group.
215
self.control_files._finish_transaction()
216
if self.is_write_locked():
217
self.control_files._set_write_transaction()
219
self.control_files._set_read_transaction()
222
def reconcile(self, other=None, thorough=False):
223
"""Reconcile this repository."""
224
from bzrlib.reconcile import KnitReconciler
225
reconciler = KnitReconciler(self, thorough=thorough)
226
reconciler.reconcile()
229
def _make_parents_provider(self):
230
return _KnitsParentsProvider(self.revisions)
232
def _find_inconsistent_revision_parents(self):
233
"""Find revisions with different parent lists in the revision object
234
and in the index graph.
236
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
237
parents-in-revision).
239
if not self.is_locked():
240
raise AssertionError()
242
for index_version in vf.keys():
243
parent_map = vf.get_parent_map([index_version])
244
parents_according_to_index = tuple(parent[-1] for parent in
245
parent_map[index_version])
246
revision = self.get_revision(index_version[-1])
247
parents_according_to_revision = tuple(revision.parent_ids)
248
if parents_according_to_index != parents_according_to_revision:
249
yield (index_version[-1], parents_according_to_index,
250
parents_according_to_revision)
252
def _check_for_inconsistent_revision_parents(self):
253
inconsistencies = list(self._find_inconsistent_revision_parents())
255
raise errors.BzrCheckError(
256
"Revision knit has inconsistent parents.")
258
def revision_graph_can_have_wrong_parents(self):
259
# The revision.kndx could potentially claim a revision has a different
260
# parent to the revision text.
264
class RepositoryFormatKnit(MetaDirRepositoryFormat):
265
"""Bzr repository knit format (generalized).
267
This repository format has:
268
- knits for file texts and inventory
269
- hash subdirectory based stores.
270
- knits for revisions and signatures
271
- TextStores for revisions and signatures.
272
- a format marker of its own
273
- an optional 'shared-storage' flag
274
- an optional 'no-working-trees' flag
278
# Set this attribute in derived classes to control the repository class
279
# created by open and initialize.
280
repository_class = None
281
# Set this attribute in derived classes to control the
282
# _commit_builder_class that the repository objects will have passed to
284
_commit_builder_class = None
285
# Set this attribute in derived clases to control the _serializer that the
286
# repository objects will have passed to their constructor.
288
def _serializer(self):
289
return xml5.serializer_v5
290
# Knit based repositories handle ghosts reasonably well.
291
supports_ghosts = True
292
# External lookups are not supported in this format.
293
supports_external_lookups = False
295
supports_chks = False
296
_fetch_order = 'topological'
297
_fetch_uses_deltas = True
300
def _get_inventories(self, repo_transport, repo, name='inventory'):
301
mapper = versionedfile.ConstantMapper(name)
302
index = _mod_knit._KndxIndex(repo_transport, mapper,
303
repo.get_transaction, repo.is_write_locked, repo.is_locked)
304
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
305
return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
307
def _get_revisions(self, repo_transport, repo):
308
mapper = versionedfile.ConstantMapper('revisions')
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_signatures(self, repo_transport, repo):
316
mapper = versionedfile.ConstantMapper('signatures')
317
index = _mod_knit._KndxIndex(repo_transport, mapper,
318
repo.get_transaction, repo.is_write_locked, repo.is_locked)
319
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
320
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
323
def _get_texts(self, repo_transport, repo):
324
mapper = versionedfile.HashEscapedPrefixMapper()
325
base_transport = repo_transport.clone('knits')
326
index = _mod_knit._KndxIndex(base_transport, mapper,
327
repo.get_transaction, repo.is_write_locked, repo.is_locked)
328
access = _mod_knit._KnitKeyAccess(base_transport, mapper)
329
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
332
def initialize(self, a_bzrdir, shared=False):
333
"""Create a knit format 1 repository.
335
:param a_bzrdir: bzrdir to contain the new repository; must already
337
:param shared: If true the repository will be initialized as a shared
340
mutter('creating repository in %s.', a_bzrdir.transport.base)
343
utf8_files = [('format', self.get_format_string())]
345
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
346
repo_transport = a_bzrdir.get_repository_transport(None)
347
control_files = lockable_files.LockableFiles(repo_transport,
348
'lock', lockdir.LockDir)
349
transaction = transactions.WriteTransaction()
350
result = self.open(a_bzrdir=a_bzrdir, _found=True)
352
# the revision id here is irrelevant: it will not be stored, and cannot
353
# already exist, we do this to create files on disk for older clients.
354
result.inventories.get_parent_map([('A',)])
355
result.revisions.get_parent_map([('A',)])
356
result.signatures.get_parent_map([('A',)])
360
def open(self, a_bzrdir, _found=False, _override_transport=None):
361
"""See RepositoryFormat.open().
363
:param _override_transport: INTERNAL USE ONLY. Allows opening the
364
repository at a slightly different url
365
than normal. I.e. during 'upgrade'.
368
format = RepositoryFormat.find_format(a_bzrdir)
369
if _override_transport is not None:
370
repo_transport = _override_transport
372
repo_transport = a_bzrdir.get_repository_transport(None)
373
control_files = lockable_files.LockableFiles(repo_transport,
374
'lock', lockdir.LockDir)
375
repo = self.repository_class(_format=self,
377
control_files=control_files,
378
_commit_builder_class=self._commit_builder_class,
379
_serializer=self._serializer)
380
repo.revisions = self._get_revisions(repo_transport, repo)
381
repo.signatures = self._get_signatures(repo_transport, repo)
382
repo.inventories = self._get_inventories(repo_transport, repo)
383
repo.texts = self._get_texts(repo_transport, repo)
384
repo.chk_bytes = None
385
repo._transport = repo_transport
389
class RepositoryFormatKnit1(RepositoryFormatKnit):
390
"""Bzr repository knit format 1.
392
This repository format has:
393
- knits for file texts and inventory
394
- hash subdirectory based stores.
395
- knits for revisions and signatures
396
- TextStores for revisions and signatures.
397
- a format marker of its own
398
- an optional 'shared-storage' flag
399
- an optional 'no-working-trees' flag
402
This format was introduced in bzr 0.8.
405
repository_class = KnitRepository
406
_commit_builder_class = CommitBuilder
408
def _serializer(self):
409
return xml5.serializer_v5
411
def __ne__(self, other):
412
return self.__class__ is not other.__class__
414
def get_format_string(self):
415
"""See RepositoryFormat.get_format_string()."""
416
return "Bazaar-NG Knit Repository Format 1"
418
def get_format_description(self):
419
"""See RepositoryFormat.get_format_description()."""
420
return "Knit repository format 1"
422
def check_conversion_target(self, target_format):
426
class RepositoryFormatKnit3(RepositoryFormatKnit):
427
"""Bzr repository knit format 3.
429
This repository format has:
430
- knits for file texts and inventory
431
- hash subdirectory based stores.
432
- knits for revisions and signatures
433
- TextStores for revisions and signatures.
434
- a format marker of its own
435
- an optional 'shared-storage' flag
436
- an optional 'no-working-trees' flag
438
- support for recording full info about the tree root
439
- support for recording tree-references
442
repository_class = KnitRepository
443
_commit_builder_class = RootCommitBuilder
444
rich_root_data = True
445
supports_tree_reference = True
447
def _serializer(self):
448
return xml7.serializer_v7
450
def _get_matching_bzrdir(self):
451
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
453
def _ignore_setting_bzrdir(self, format):
456
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
458
def check_conversion_target(self, target_format):
459
if not target_format.rich_root_data:
460
raise errors.BadConversionTarget(
461
'Does not support rich root data.', target_format)
462
if not getattr(target_format, 'supports_tree_reference', False):
463
raise errors.BadConversionTarget(
464
'Does not support nested trees', target_format)
466
def get_format_string(self):
467
"""See RepositoryFormat.get_format_string()."""
468
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
470
def get_format_description(self):
471
"""See RepositoryFormat.get_format_description()."""
472
return "Knit repository format 3"
475
class RepositoryFormatKnit4(RepositoryFormatKnit):
476
"""Bzr repository knit format 4.
478
This repository format has everything in format 3, except for
480
- knits for file texts and inventory
481
- hash subdirectory based stores.
482
- knits for revisions and signatures
483
- TextStores for revisions and signatures.
484
- a format marker of its own
485
- an optional 'shared-storage' flag
486
- an optional 'no-working-trees' flag
488
- support for recording full info about the tree root
491
repository_class = KnitRepository
492
_commit_builder_class = RootCommitBuilder
493
rich_root_data = True
494
supports_tree_reference = False
496
def _serializer(self):
497
return xml6.serializer_v6
499
def _get_matching_bzrdir(self):
500
return bzrdir.format_registry.make_bzrdir('rich-root')
502
def _ignore_setting_bzrdir(self, format):
505
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
507
def check_conversion_target(self, target_format):
508
if not target_format.rich_root_data:
509
raise errors.BadConversionTarget(
510
'Does not support rich root data.', target_format)
512
def get_format_string(self):
513
"""See RepositoryFormat.get_format_string()."""
514
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
516
def get_format_description(self):
517
"""See RepositoryFormat.get_format_description()."""
518
return "Knit repository format 4"
added
removed
bzrlib/repofmt/knitrepo.py
