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
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
39
from bzrlib.knit import KnitVersionedFiles, _KndxIndex, _KnitKeyAccess
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
51
from bzrlib.versionedfile import ConstantMapper, HashEscapedPrefixMapper
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 _KnitsParentsProvider(object):
89
def __init__(self, knit, prefix=()):
90
"""Create a parent provider for string keys mapped to tuple keys."""
95
return 'KnitsParentsProvider(%r)' % self._knit
97
def get_parent_map(self, keys):
98
"""See graph._StackedParentsProvider.get_parent_map"""
99
parent_map = self._knit.get_parent_map(
100
[self._prefix + (key,) for key in keys])
102
for key, parents in parent_map.items():
104
if len(parents) == 0:
105
parents = (_mod_revision.NULL_REVISION,)
107
parents = tuple(parent[-1] for parent in parents)
108
result[revid] = parents
109
for revision_id in keys:
110
if revision_id == _mod_revision.NULL_REVISION:
111
result[revision_id] = ()
115
class KnitRepository(MetaDirRepository):
116
"""Knit format repository."""
118
# These attributes are inherited from the Repository base class. Setting
119
# them to None ensures that if the constructor is changed to not initialize
120
# them, or a subclass fails to call the constructor, that an error will
121
# occur rather than the system working but generating incorrect data.
122
_commit_builder_class = None
125
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
127
MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
128
self._commit_builder_class = _commit_builder_class
129
self._serializer = _serializer
130
self._reconcile_fixes_text_parents = True
132
def _warn_if_deprecated(self):
133
# This class isn't deprecated
137
def _all_revision_ids(self):
138
"""See Repository.all_revision_ids()."""
139
return [key[0] for key in self.revisions.keys()]
141
def _activate_new_inventory(self):
142
"""Put a replacement inventory.new into use as inventories."""
143
# Copy the content across
145
t.copy('inventory.new.kndx', 'inventory.kndx')
147
t.copy('inventory.new.knit', 'inventory.knit')
148
except errors.NoSuchFile:
149
# empty inventories knit
150
t.delete('inventory.knit')
151
# delete the temp inventory
152
t.delete('inventory.new.kndx')
154
t.delete('inventory.new.knit')
155
except errors.NoSuchFile:
156
# empty inventories knit
158
# Force index reload (sanity check)
159
self.inventories._index._reset_cache()
160
self.inventories.keys()
162
def _backup_inventory(self):
164
t.copy('inventory.kndx', 'inventory.backup.kndx')
165
t.copy('inventory.knit', 'inventory.backup.knit')
167
def _move_file_id(self, from_id, to_id):
168
t = self._transport.clone('knits')
169
from_rel_url = self.texts._index._mapper.map((from_id, None))
170
to_rel_url = self.texts._index._mapper.map((to_id, None))
171
# We expect both files to always exist in this case.
172
for suffix in ('.knit', '.kndx'):
173
t.rename(from_rel_url + suffix, to_rel_url + suffix)
175
def _remove_file_id(self, file_id):
176
t = self._transport.clone('knits')
177
rel_url = self.texts._index._mapper.map((file_id, None))
178
for suffix in ('.kndx', '.knit'):
180
t.delete(rel_url + suffix)
181
except errors.NoSuchFile:
184
def _temp_inventories(self):
185
result = self._format._get_inventories(self._transport, self,
187
# Reconciling when the output has no revisions would result in no
188
# writes - but we want to ensure there is an inventory for
189
# compatibility with older clients that don't lazy-load.
190
result.get_parent_map([('A',)])
193
def fileid_involved_between_revs(self, from_revid, to_revid):
194
"""Find file_id(s) which are involved in the changes between revisions.
196
This determines the set of revisions which are involved, and then
197
finds all file ids affected by those revisions.
199
vf = self._get_revision_vf()
200
from_set = set(vf.get_ancestry(from_revid))
201
to_set = set(vf.get_ancestry(to_revid))
202
changed = to_set.difference(from_set)
203
return self._fileid_involved_by_set(changed)
205
def fileid_involved(self, last_revid=None):
206
"""Find all file_ids modified in the ancestry of last_revid.
208
:param last_revid: If None, last_revision() will be used.
211
changed = set(self.all_revision_ids())
213
changed = set(self.get_ancestry(last_revid))
216
return self._fileid_involved_by_set(changed)
219
def get_revision(self, revision_id):
220
"""Return the Revision object for a named revision"""
221
revision_id = osutils.safe_revision_id(revision_id)
222
return self.get_revision_reconcile(revision_id)
225
def reconcile(self, other=None, thorough=False):
226
"""Reconcile this repository."""
227
from bzrlib.reconcile import KnitReconciler
228
reconciler = KnitReconciler(self, thorough=thorough)
229
reconciler.reconcile()
232
@symbol_versioning.deprecated_method(symbol_versioning.one_five)
233
def revision_parents(self, revision_id):
234
return self._get_revision_vf().get_parents(revision_id)
236
def _make_parents_provider(self):
237
return _KnitsParentsProvider(self.revisions)
239
def _find_inconsistent_revision_parents(self):
240
"""Find revisions with different parent lists in the revision object
241
and in the index graph.
243
:returns: an iterator yielding tuples of (revison-id, parents-in-index,
244
parents-in-revision).
246
if not self.is_locked():
247
raise AssertionError()
249
for index_version in vf.keys():
250
parent_map = vf.get_parent_map([index_version])
251
parents_according_to_index = tuple(parent[-1] for parent in
252
parent_map[index_version])
253
revision = self.get_revision(index_version[-1])
254
parents_according_to_revision = tuple(revision.parent_ids)
255
if parents_according_to_index != parents_according_to_revision:
256
yield (index_version[-1], parents_according_to_index,
257
parents_according_to_revision)
259
def _check_for_inconsistent_revision_parents(self):
260
inconsistencies = list(self._find_inconsistent_revision_parents())
262
raise errors.BzrCheckError(
263
"Revision knit has inconsistent parents.")
265
def revision_graph_can_have_wrong_parents(self):
266
# The revision.kndx could potentially claim a revision has a different
267
# parent to the revision text.
271
class RepositoryFormatKnit(MetaDirRepositoryFormat):
272
"""Bzr repository knit format (generalized).
274
This repository format has:
275
- knits for file texts and inventory
276
- hash subdirectory based stores.
277
- knits for revisions and signatures
278
- TextStores for revisions and signatures.
279
- a format marker of its own
280
- an optional 'shared-storage' flag
281
- an optional 'no-working-trees' flag
285
# Set this attribute in derived classes to control the repository class
286
# created by open and initialize.
287
repository_class = None
288
# Set this attribute in derived classes to control the
289
# _commit_builder_class that the repository objects will have passed to
291
_commit_builder_class = None
292
# Set this attribute in derived clases to control the _serializer that the
293
# repository objects will have passed to their constructor.
294
_serializer = xml5.serializer_v5
295
# Knit based repositories handle ghosts reasonably well.
296
supports_ghosts = True
297
# External lookups are not supported in this format.
298
supports_external_lookups = False
300
def _get_inventories(self, repo_transport, repo, name='inventory'):
301
mapper = ConstantMapper(name)
302
index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
303
repo.is_write_locked, repo.is_locked)
304
access = _KnitKeyAccess(repo_transport, mapper)
305
return KnitVersionedFiles(index, access, annotated=False)
307
def _get_revisions(self, repo_transport, repo):
308
mapper = ConstantMapper('revisions')
309
index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
310
repo.is_write_locked, repo.is_locked)
311
access = _KnitKeyAccess(repo_transport, mapper)
312
return KnitVersionedFiles(index, access, max_delta_chain=0,
315
def _get_signatures(self, repo_transport, repo):
316
mapper = ConstantMapper('signatures')
317
index = _KndxIndex(repo_transport, mapper, repo.get_transaction,
318
repo.is_write_locked, repo.is_locked)
319
access = _KnitKeyAccess(repo_transport, mapper)
320
return KnitVersionedFiles(index, access, max_delta_chain=0,
323
def _get_texts(self, repo_transport, repo):
324
mapper = HashEscapedPrefixMapper()
325
base_transport = repo_transport.clone('knits')
326
index = _KndxIndex(base_transport, mapper, repo.get_transaction,
327
repo.is_write_locked, repo.is_locked)
328
access = _KnitKeyAccess(base_transport, mapper)
329
return 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._transport = repo_transport
388
class RepositoryFormatKnit1(RepositoryFormatKnit):
389
"""Bzr repository knit format 1.
391
This repository format has:
392
- knits for file texts and inventory
393
- hash subdirectory based stores.
394
- knits for revisions and signatures
395
- TextStores for revisions and signatures.
396
- a format marker of its own
397
- an optional 'shared-storage' flag
398
- an optional 'no-working-trees' flag
401
This format was introduced in bzr 0.8.
404
repository_class = KnitRepository
405
_commit_builder_class = CommitBuilder
406
_serializer = xml5.serializer_v5
408
def __ne__(self, other):
409
return self.__class__ is not other.__class__
411
def get_format_string(self):
412
"""See RepositoryFormat.get_format_string()."""
413
return "Bazaar-NG Knit Repository Format 1"
415
def get_format_description(self):
416
"""See RepositoryFormat.get_format_description()."""
417
return "Knit repository format 1"
419
def check_conversion_target(self, target_format):
423
class RepositoryFormatKnit3(RepositoryFormatKnit):
424
"""Bzr repository knit format 3.
426
This repository format has:
427
- knits for file texts and inventory
428
- hash subdirectory based stores.
429
- knits for revisions and signatures
430
- TextStores for revisions and signatures.
431
- a format marker of its own
432
- an optional 'shared-storage' flag
433
- an optional 'no-working-trees' flag
435
- support for recording full info about the tree root
436
- support for recording tree-references
439
repository_class = KnitRepository
440
_commit_builder_class = RootCommitBuilder
441
rich_root_data = True
442
supports_tree_reference = True
443
_serializer = xml7.serializer_v7
445
def _get_matching_bzrdir(self):
446
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
448
def _ignore_setting_bzrdir(self, format):
451
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
453
def check_conversion_target(self, target_format):
454
if not target_format.rich_root_data:
455
raise errors.BadConversionTarget(
456
'Does not support rich root data.', target_format)
457
if not getattr(target_format, 'supports_tree_reference', False):
458
raise errors.BadConversionTarget(
459
'Does not support nested trees', target_format)
461
def get_format_string(self):
462
"""See RepositoryFormat.get_format_string()."""
463
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
465
def get_format_description(self):
466
"""See RepositoryFormat.get_format_description()."""
467
return "Knit repository format 3"
470
class RepositoryFormatKnit4(RepositoryFormatKnit):
471
"""Bzr repository knit format 4.
473
This repository format has everything in format 3, except for
475
- knits for file texts and inventory
476
- hash subdirectory based stores.
477
- knits for revisions and signatures
478
- TextStores for revisions and signatures.
479
- a format marker of its own
480
- an optional 'shared-storage' flag
481
- an optional 'no-working-trees' flag
483
- support for recording full info about the tree root
486
repository_class = KnitRepository
487
_commit_builder_class = RootCommitBuilder
488
rich_root_data = True
489
supports_tree_reference = False
490
_serializer = xml6.serializer_v6
492
def _get_matching_bzrdir(self):
493
return bzrdir.format_registry.make_bzrdir('rich-root')
495
def _ignore_setting_bzrdir(self, format):
498
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
500
def check_conversion_target(self, target_format):
501
if not target_format.rich_root_data:
502
raise errors.BadConversionTarget(
503
'Does not support rich root data.', target_format)
505
def get_format_string(self):
506
"""See RepositoryFormat.get_format_string()."""
507
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
509
def get_format_description(self):
510
"""See RepositoryFormat.get_format_description()."""
511
return "Knit repository format 4"
added
removed
bzrlib/repofmt/knitrepo.py
