1
# Copyright (C) 2007-2010 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,
35
from bzrlib.decorators import needs_read_lock, needs_write_lock
36
from bzrlib.repository import (
41
from bzrlib.vf_repository import (
42
InterSameDataRepository,
43
MetaDirVersionedFileRepository,
44
MetaDirVersionedFileRepositoryFormat,
45
VersionedFileCommitBuilder,
46
VersionedFileRootCommitBuilder,
48
from bzrlib import symbol_versioning
51
class _KnitParentsProvider(object):
53
def __init__(self, knit):
57
return 'KnitParentsProvider(%r)' % self._knit
59
def get_parent_map(self, keys):
60
"""See graph.StackedParentsProvider.get_parent_map"""
62
for revision_id in keys:
63
if revision_id is None:
64
raise ValueError('get_parent_map(None) is not valid')
65
if revision_id == _mod_revision.NULL_REVISION:
66
parent_map[revision_id] = ()
70
self._knit.get_parents_with_ghosts(revision_id))
71
except errors.RevisionNotPresent:
75
parents = (_mod_revision.NULL_REVISION,)
76
parent_map[revision_id] = parents
80
class _KnitsParentsProvider(object):
82
def __init__(self, knit, prefix=()):
83
"""Create a parent provider for string keys mapped to tuple keys."""
88
return 'KnitsParentsProvider(%r)' % self._knit
90
def get_parent_map(self, keys):
91
"""See graph.StackedParentsProvider.get_parent_map"""
92
parent_map = self._knit.get_parent_map(
93
[self._prefix + (key,) for key in keys])
95
for key, parents in parent_map.items():
98
parents = (_mod_revision.NULL_REVISION,)
100
parents = tuple(parent[-1] for parent in parents)
101
result[revid] = parents
102
for revision_id in keys:
103
if revision_id == _mod_revision.NULL_REVISION:
104
result[revision_id] = ()
108
class KnitRepository(MetaDirVersionedFileRepository):
109
"""Knit format repository."""
111
# These attributes are inherited from the Repository base class. Setting
112
# them to None ensures that if the constructor is changed to not initialize
113
# them, or a subclass fails to call the constructor, that an error will
114
# occur rather than the system working but generating incorrect data.
115
_commit_builder_class = None
118
def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
120
super(KnitRepository, self).__init__(_format, a_bzrdir, control_files)
121
self._commit_builder_class = _commit_builder_class
122
self._serializer = _serializer
123
self._reconcile_fixes_text_parents = True
126
def _all_revision_ids(self):
127
"""See Repository.all_revision_ids()."""
128
return [key[0] for key in self.revisions.keys()]
130
def _activate_new_inventory(self):
131
"""Put a replacement inventory.new into use as inventories."""
132
# Copy the content across
134
t.copy('inventory.new.kndx', 'inventory.kndx')
136
t.copy('inventory.new.knit', 'inventory.knit')
137
except errors.NoSuchFile:
138
# empty inventories knit
139
t.delete('inventory.knit')
140
# delete the temp inventory
141
t.delete('inventory.new.kndx')
143
t.delete('inventory.new.knit')
144
except errors.NoSuchFile:
145
# empty inventories knit
147
# Force index reload (sanity check)
148
self.inventories._index._reset_cache()
149
self.inventories.keys()
151
def _backup_inventory(self):
153
t.copy('inventory.kndx', 'inventory.backup.kndx')
154
t.copy('inventory.knit', 'inventory.backup.knit')
156
def _move_file_id(self, from_id, to_id):
157
t = self._transport.clone('knits')
158
from_rel_url = self.texts._index._mapper.map((from_id, None))
159
to_rel_url = self.texts._index._mapper.map((to_id, None))
160
# We expect both files to always exist in this case.
161
for suffix in ('.knit', '.kndx'):
162
t.rename(from_rel_url + suffix, to_rel_url + suffix)
164
def _remove_file_id(self, file_id):
165
t = self._transport.clone('knits')
166
rel_url = self.texts._index._mapper.map((file_id, None))
167
for suffix in ('.kndx', '.knit'):
169
t.delete(rel_url + suffix)
170
except errors.NoSuchFile:
173
def _temp_inventories(self):
174
result = self._format._get_inventories(self._transport, self,
176
# Reconciling when the output has no revisions would result in no
177
# writes - but we want to ensure there is an inventory for
178
# compatibility with older clients that don't lazy-load.
179
result.get_parent_map([('A',)])
182
def fileid_involved_between_revs(self, from_revid, to_revid):
183
"""Find file_id(s) which are involved in the changes between revisions.
185
This determines the set of revisions which are involved, and then
186
finds all file ids affected by those revisions.
188
vf = self._get_revision_vf()
189
from_set = set(vf.get_ancestry(from_revid))
190
to_set = set(vf.get_ancestry(to_revid))
191
changed = to_set.difference(from_set)
192
return self._fileid_involved_by_set(changed)
194
def fileid_involved(self, last_revid=None):
195
"""Find all file_ids modified in the ancestry of last_revid.
197
:param last_revid: If None, last_revision() will be used.
200
changed = set(self.all_revision_ids())
202
changed = set(self.get_ancestry(last_revid))
205
return self._fileid_involved_by_set(changed)
208
def get_revision(self, revision_id):
209
"""Return the Revision object for a named revision"""
210
revision_id = osutils.safe_revision_id(revision_id)
211
return self.get_revision_reconcile(revision_id)
213
def _refresh_data(self):
214
if not self.is_locked():
216
if self.is_in_write_group():
217
raise IsInWriteGroupError(self)
218
# Create a new transaction to force all knits to see the scope change.
219
# This is safe because we're outside a write group.
220
self.control_files._finish_transaction()
221
if self.is_write_locked():
222
self.control_files._set_write_transaction()
224
self.control_files._set_read_transaction()
227
def reconcile(self, other=None, thorough=False):
228
"""Reconcile this repository."""
229
from bzrlib.reconcile import KnitReconciler
230
reconciler = KnitReconciler(self, thorough=thorough)
231
reconciler.reconcile()
234
def _make_parents_provider(self):
235
return _KnitsParentsProvider(self.revisions)
238
class RepositoryFormatKnit(MetaDirVersionedFileRepositoryFormat):
239
"""Bzr repository knit format (generalized).
241
This repository format has:
242
- knits for file texts and inventory
243
- hash subdirectory based stores.
244
- knits for revisions and signatures
245
- TextStores for revisions and signatures.
246
- a format marker of its own
247
- an optional 'shared-storage' flag
248
- an optional 'no-working-trees' flag
252
# Set this attribute in derived classes to control the repository class
253
# created by open and initialize.
254
repository_class = None
255
# Set this attribute in derived classes to control the
256
# _commit_builder_class that the repository objects will have passed to
258
_commit_builder_class = None
259
# Set this attribute in derived clases to control the _serializer that the
260
# repository objects will have passed to their constructor.
262
def _serializer(self):
263
return xml5.serializer_v5
264
# Knit based repositories handle ghosts reasonably well.
265
supports_ghosts = True
266
# External lookups are not supported in this format.
267
supports_external_lookups = False
269
supports_chks = False
270
_fetch_order = 'topological'
271
_fetch_uses_deltas = True
273
supports_funky_characters = True
274
# The revision.kndx could potentially claim a revision has a different
275
# parent to the revision text.
276
revision_graph_can_have_wrong_parents = True
278
def _get_inventories(self, repo_transport, repo, name='inventory'):
279
mapper = versionedfile.ConstantMapper(name)
280
index = _mod_knit._KndxIndex(repo_transport, mapper,
281
repo.get_transaction, repo.is_write_locked, repo.is_locked)
282
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
283
return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
285
def _get_revisions(self, repo_transport, repo):
286
mapper = versionedfile.ConstantMapper('revisions')
287
index = _mod_knit._KndxIndex(repo_transport, mapper,
288
repo.get_transaction, repo.is_write_locked, repo.is_locked)
289
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
290
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
293
def _get_signatures(self, repo_transport, repo):
294
mapper = versionedfile.ConstantMapper('signatures')
295
index = _mod_knit._KndxIndex(repo_transport, mapper,
296
repo.get_transaction, repo.is_write_locked, repo.is_locked)
297
access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
298
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
301
def _get_texts(self, repo_transport, repo):
302
mapper = versionedfile.HashEscapedPrefixMapper()
303
base_transport = repo_transport.clone('knits')
304
index = _mod_knit._KndxIndex(base_transport, mapper,
305
repo.get_transaction, repo.is_write_locked, repo.is_locked)
306
access = _mod_knit._KnitKeyAccess(base_transport, mapper)
307
return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
310
def initialize(self, a_bzrdir, shared=False):
311
"""Create a knit format 1 repository.
313
:param a_bzrdir: bzrdir to contain the new repository; must already
315
:param shared: If true the repository will be initialized as a shared
318
trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
321
utf8_files = [('format', self.get_format_string())]
323
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
324
repo_transport = a_bzrdir.get_repository_transport(None)
325
control_files = lockable_files.LockableFiles(repo_transport,
326
'lock', lockdir.LockDir)
327
transaction = transactions.WriteTransaction()
328
result = self.open(a_bzrdir=a_bzrdir, _found=True)
330
# the revision id here is irrelevant: it will not be stored, and cannot
331
# already exist, we do this to create files on disk for older clients.
332
result.inventories.get_parent_map([('A',)])
333
result.revisions.get_parent_map([('A',)])
334
result.signatures.get_parent_map([('A',)])
336
self._run_post_repo_init_hooks(result, a_bzrdir, shared)
339
def open(self, a_bzrdir, _found=False, _override_transport=None):
340
"""See RepositoryFormat.open().
342
:param _override_transport: INTERNAL USE ONLY. Allows opening the
343
repository at a slightly different url
344
than normal. I.e. during 'upgrade'.
347
format = RepositoryFormat.find_format(a_bzrdir)
348
if _override_transport is not None:
349
repo_transport = _override_transport
351
repo_transport = a_bzrdir.get_repository_transport(None)
352
control_files = lockable_files.LockableFiles(repo_transport,
353
'lock', lockdir.LockDir)
354
repo = self.repository_class(_format=self,
356
control_files=control_files,
357
_commit_builder_class=self._commit_builder_class,
358
_serializer=self._serializer)
359
repo.revisions = self._get_revisions(repo_transport, repo)
360
repo.signatures = self._get_signatures(repo_transport, repo)
361
repo.inventories = self._get_inventories(repo_transport, repo)
362
repo.texts = self._get_texts(repo_transport, repo)
363
repo.chk_bytes = None
364
repo._transport = repo_transport
368
class RepositoryFormatKnit1(RepositoryFormatKnit):
369
"""Bzr repository knit format 1.
371
This repository format has:
372
- knits for file texts and inventory
373
- hash subdirectory based stores.
374
- knits for revisions and signatures
375
- TextStores for revisions and signatures.
376
- a format marker of its own
377
- an optional 'shared-storage' flag
378
- an optional 'no-working-trees' flag
381
This format was introduced in bzr 0.8.
384
repository_class = KnitRepository
385
_commit_builder_class = VersionedFileCommitBuilder
387
def _serializer(self):
388
return xml5.serializer_v5
390
def __ne__(self, other):
391
return self.__class__ is not other.__class__
393
def get_format_string(self):
394
"""See RepositoryFormat.get_format_string()."""
395
return "Bazaar-NG Knit Repository Format 1"
397
def get_format_description(self):
398
"""See RepositoryFormat.get_format_description()."""
399
return "Knit repository format 1"
402
class RepositoryFormatKnit3(RepositoryFormatKnit):
403
"""Bzr repository knit format 3.
405
This repository format has:
406
- knits for file texts and inventory
407
- hash subdirectory based stores.
408
- knits for revisions and signatures
409
- TextStores for revisions and signatures.
410
- a format marker of its own
411
- an optional 'shared-storage' flag
412
- an optional 'no-working-trees' flag
414
- support for recording full info about the tree root
415
- support for recording tree-references
418
repository_class = KnitRepository
419
_commit_builder_class = VersionedFileRootCommitBuilder
420
rich_root_data = True
422
supports_tree_reference = True
424
def _serializer(self):
425
return xml7.serializer_v7
427
def _get_matching_bzrdir(self):
428
return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
430
def _ignore_setting_bzrdir(self, format):
433
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
435
def get_format_string(self):
436
"""See RepositoryFormat.get_format_string()."""
437
return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
439
def get_format_description(self):
440
"""See RepositoryFormat.get_format_description()."""
441
return "Knit repository format 3"
444
class RepositoryFormatKnit4(RepositoryFormatKnit):
445
"""Bzr repository knit format 4.
447
This repository format has everything in format 3, except for
449
- knits for file texts and inventory
450
- hash subdirectory based stores.
451
- knits for revisions and signatures
452
- TextStores for revisions and signatures.
453
- a format marker of its own
454
- an optional 'shared-storage' flag
455
- an optional 'no-working-trees' flag
457
- support for recording full info about the tree root
460
repository_class = KnitRepository
461
_commit_builder_class = VersionedFileRootCommitBuilder
462
rich_root_data = True
463
supports_tree_reference = False
465
def _serializer(self):
466
return xml6.serializer_v6
468
def _get_matching_bzrdir(self):
469
return bzrdir.format_registry.make_bzrdir('rich-root')
471
def _ignore_setting_bzrdir(self, format):
474
_matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
476
def get_format_string(self):
477
"""See RepositoryFormat.get_format_string()."""
478
return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
480
def get_format_description(self):
481
"""See RepositoryFormat.get_format_description()."""
482
return "Knit repository format 4"
485
class InterKnitRepo(InterSameDataRepository):
486
"""Optimised code paths between Knit based repositories."""
489
def _get_repo_format_to_test(self):
490
return RepositoryFormatKnit1()
493
def is_compatible(source, target):
494
"""Be compatible with known Knit formats.
496
We don't test for the stores being of specific types because that
497
could lead to confusing results, and there is no need to be
501
are_knits = (isinstance(source._format, RepositoryFormatKnit) and
502
isinstance(target._format, RepositoryFormatKnit))
503
except AttributeError:
505
return are_knits and InterRepository._same_model(source, target)
508
def search_missing_revision_ids(self,
509
revision_id=symbol_versioning.DEPRECATED_PARAMETER,
510
find_ghosts=True, revision_ids=None, if_present_ids=None):
511
"""See InterRepository.search_missing_revision_ids()."""
512
if symbol_versioning.deprecated_passed(revision_id):
513
symbol_versioning.warn(
514
'search_missing_revision_ids(revision_id=...) was '
515
'deprecated in 2.4. Use revision_ids=[...] instead.',
516
DeprecationWarning, stacklevel=2)
517
if revision_ids is not None:
518
raise AssertionError(
519
'revision_ids is mutually exclusive with revision_id')
520
if revision_id is not None:
521
revision_ids = [revision_id]
523
source_ids_set = self._present_source_revisions_for(
524
revision_ids, if_present_ids)
525
# source_ids is the worst possible case we may need to pull.
526
# now we want to filter source_ids against what we actually
527
# have in target, but don't try to check for existence where we know
528
# we do not have a revision as that would be pointless.
529
target_ids = set(self.target.all_revision_ids())
530
possibly_present_revisions = target_ids.intersection(source_ids_set)
531
actually_present_revisions = set(
532
self.target._eliminate_revisions_not_present(possibly_present_revisions))
533
required_revisions = source_ids_set.difference(actually_present_revisions)
534
if revision_ids is not None:
535
# we used get_ancestry to determine source_ids then we are assured all
536
# revisions referenced are present as they are installed in topological order.
537
# and the tip revision was validated by get_ancestry.
538
result_set = required_revisions
540
# if we just grabbed the possibly available ids, then
541
# we only have an estimate of whats available and need to validate
542
# that against the revision records.
544
self.source._eliminate_revisions_not_present(required_revisions))
545
return self.source.revision_ids_to_search_result(result_set)
548
InterRepository.register_optimiser(InterKnitRepo)
added
removed
bzrlib/repofmt/knitrepo.py
