/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/knitrepo.py

  • Committer: Robert Collins
  • Date: 2008-07-28 05:09:54 UTC
  • mto: This revision was merged to the branch mainline in revision 3584.
  • Revision ID: robertc@robertcollins.net-20080728050954-iyok0yyqonml80q7
 * The generic fetch code now uses two attributes on Repository objects
   to control the requested streams: ``_fetch_order`` and
   ``_fetch_uses_deltas``. Setting these appropriately allows different
   repository implementations to recieve data in their optimial form.
   (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
 
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.
 
7
#
 
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.
 
12
#
 
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
 
16
 
 
17
from bzrlib.lazy_import import lazy_import
 
18
lazy_import(globals(), """
 
19
from bzrlib import (
 
20
    debug,
 
21
    )
 
22
from bzrlib.store import revision
 
23
from bzrlib.store.revision.knit import KnitRevisionStore
 
24
""")
 
25
from bzrlib import (
 
26
    bzrdir,
 
27
    errors,
 
28
    knit,
 
29
    lockable_files,
 
30
    lockdir,
 
31
    osutils,
 
32
    symbol_versioning,
 
33
    transactions,
 
34
    xml5,
 
35
    xml6,
 
36
    xml7,
 
37
    )
 
38
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
39
from bzrlib.knit import KnitVersionedFiles, _KndxIndex, _KnitKeyAccess
 
40
from bzrlib.repository import (
 
41
    CommitBuilder,
 
42
    MetaDirRepository,
 
43
    MetaDirRepositoryFormat,
 
44
    RepositoryFormat,
 
45
    RootCommitBuilder,
 
46
    )
 
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
 
52
 
 
53
 
 
54
class _KnitParentsProvider(object):
 
55
 
 
56
    def __init__(self, knit):
 
57
        self._knit = knit
 
58
 
 
59
    def __repr__(self):
 
60
        return 'KnitParentsProvider(%r)' % self._knit
 
61
 
 
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]
 
67
 
 
68
    def get_parent_map(self, keys):
 
69
        """See graph._StackedParentsProvider.get_parent_map"""
 
70
        parent_map = {}
 
71
        for revision_id in keys:
 
72
            if revision_id is None:
 
73
                raise ValueError('get_parent_map(None) is not valid')
 
74
            if revision_id == _mod_revision.NULL_REVISION:
 
75
                parent_map[revision_id] = ()
 
76
            else:
 
77
                try:
 
78
                    parents = tuple(
 
79
                        self._knit.get_parents_with_ghosts(revision_id))
 
80
                except errors.RevisionNotPresent:
 
81
                    continue
 
82
                else:
 
83
                    if len(parents) == 0:
 
84
                        parents = (_mod_revision.NULL_REVISION,)
 
85
                parent_map[revision_id] = parents
 
86
        return parent_map
 
87
 
 
88
 
 
89
class _KnitsParentsProvider(object):
 
90
 
 
91
    def __init__(self, knit, prefix=()):
 
92
        """Create a parent provider for string keys mapped to tuple keys."""
 
93
        self._knit = knit
 
94
        self._prefix = prefix
 
95
 
 
96
    def __repr__(self):
 
97
        return 'KnitsParentsProvider(%r)' % self._knit
 
98
 
 
99
    def get_parent_map(self, keys):
 
100
        """See graph._StackedParentsProvider.get_parent_map"""
 
101
        parent_map = self._knit.get_parent_map(
 
102
            [self._prefix + (key,) for key in keys])
 
103
        result = {}
 
104
        for key, parents in parent_map.items():
 
105
            revid = key[-1]
 
106
            if len(parents) == 0:
 
107
                parents = (_mod_revision.NULL_REVISION,)
 
108
            else:
 
109
                parents = tuple(parent[-1] for parent in parents)
 
110
            result[revid] = parents
 
111
        for revision_id in keys:
 
112
            if revision_id == _mod_revision.NULL_REVISION:
 
113
                result[revision_id] = ()
 
114
        return result
 
115
 
 
116
 
 
117
class KnitRepository(MetaDirRepository):
 
118
    """Knit format repository."""
 
119
 
 
120
    # These attributes are inherited from the Repository base class. Setting
 
121
    # them to None ensures that if the constructor is changed to not initialize
 
122
    # them, or a subclass fails to call the constructor, that an error will
 
123
    # occur rather than the system working but generating incorrect data.
 
124
    _commit_builder_class = None
 
125
    _serializer = None
 
126
 
 
127
    def __init__(self, _format, a_bzrdir, control_files, _commit_builder_class,
 
128
        _serializer):
 
129
        MetaDirRepository.__init__(self, _format, a_bzrdir, control_files)
 
130
        self._commit_builder_class = _commit_builder_class
 
131
        self._serializer = _serializer
 
132
        self._reconcile_fixes_text_parents = True
 
133
        self._fetch_uses_deltas = True
 
134
        self._fetch_order = 'topological'
 
135
 
 
136
    def _warn_if_deprecated(self):
 
137
        # This class isn't deprecated
 
138
        pass
 
139
 
 
140
    @needs_read_lock
 
141
    def _all_revision_ids(self):
 
142
        """See Repository.all_revision_ids()."""
 
143
        return [key[0] for key in self.revisions.keys()]
 
144
 
 
145
    def _activate_new_inventory(self):
 
146
        """Put a replacement inventory.new into use as inventories."""
 
147
        # Copy the content across
 
148
        t = self._transport
 
149
        t.copy('inventory.new.kndx', 'inventory.kndx')
 
150
        try:
 
151
            t.copy('inventory.new.knit', 'inventory.knit')
 
152
        except errors.NoSuchFile:
 
153
            # empty inventories knit
 
154
            t.delete('inventory.knit')
 
155
        # delete the temp inventory
 
156
        t.delete('inventory.new.kndx')
 
157
        try:
 
158
            t.delete('inventory.new.knit')
 
159
        except errors.NoSuchFile:
 
160
            # empty inventories knit
 
161
            pass
 
162
        # Force index reload (sanity check)
 
163
        self.inventories._index._reset_cache()
 
164
        self.inventories.keys()
 
165
 
 
166
    def _backup_inventory(self):
 
167
        t = self._transport
 
168
        t.copy('inventory.kndx', 'inventory.backup.kndx')
 
169
        t.copy('inventory.knit', 'inventory.backup.knit')
 
170
 
 
171
    def _move_file_id(self, from_id, to_id):
 
172
        t = self._transport.clone('knits')
 
173
        from_rel_url = self.texts._index._mapper.map((from_id, None))
 
174
        to_rel_url = self.texts._index._mapper.map((to_id, None))
 
175
        # We expect both files to always exist in this case.
 
176
        for suffix in ('.knit', '.kndx'):
 
177
            t.rename(from_rel_url + suffix, to_rel_url + suffix)
 
178
 
 
179
    def _remove_file_id(self, file_id):
 
180
        t = self._transport.clone('knits')
 
181
        rel_url = self.texts._index._mapper.map((file_id, None))
 
182
        for suffix in ('.kndx', '.knit'):
 
183
            try:
 
184
                t.delete(rel_url + suffix)
 
185
            except errors.NoSuchFile:
 
186
                pass
 
187
 
 
188
    def _temp_inventories(self):
 
189
        result = self._format._get_inventories(self._transport, self,
 
190
            'inventory.new')
 
191
        # Reconciling when the output has no revisions would result in no
 
192
        # writes - but we want to ensure there is an inventory for
 
193
        # compatibility with older clients that don't lazy-load.
 
194
        result.get_parent_map([('A',)])
 
195
        return result
 
196
 
 
197
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
198
        """Find file_id(s) which are involved in the changes between revisions.
 
199
 
 
200
        This determines the set of revisions which are involved, and then
 
201
        finds all file ids affected by those revisions.
 
202
        """
 
203
        vf = self._get_revision_vf()
 
204
        from_set = set(vf.get_ancestry(from_revid))
 
205
        to_set = set(vf.get_ancestry(to_revid))
 
206
        changed = to_set.difference(from_set)
 
207
        return self._fileid_involved_by_set(changed)
 
208
 
 
209
    def fileid_involved(self, last_revid=None):
 
210
        """Find all file_ids modified in the ancestry of last_revid.
 
211
 
 
212
        :param last_revid: If None, last_revision() will be used.
 
213
        """
 
214
        if not last_revid:
 
215
            changed = set(self.all_revision_ids())
 
216
        else:
 
217
            changed = set(self.get_ancestry(last_revid))
 
218
        if None in changed:
 
219
            changed.remove(None)
 
220
        return self._fileid_involved_by_set(changed)
 
221
 
 
222
    @needs_read_lock
 
223
    def get_revision(self, revision_id):
 
224
        """Return the Revision object for a named revision"""
 
225
        revision_id = osutils.safe_revision_id(revision_id)
 
226
        return self.get_revision_reconcile(revision_id)
 
227
 
 
228
    @needs_write_lock
 
229
    def reconcile(self, other=None, thorough=False):
 
230
        """Reconcile this repository."""
 
231
        from bzrlib.reconcile import KnitReconciler
 
232
        reconciler = KnitReconciler(self, thorough=thorough)
 
233
        reconciler.reconcile()
 
234
        return reconciler
 
235
    
 
236
    def _make_parents_provider(self):
 
237
        return _KnitsParentsProvider(self.revisions)
 
238
 
 
239
    def _find_inconsistent_revision_parents(self):
 
240
        """Find revisions with different parent lists in the revision object
 
241
        and in the index graph.
 
242
 
 
243
        :returns: an iterator yielding tuples of (revison-id, parents-in-index,
 
244
            parents-in-revision).
 
245
        """
 
246
        if not self.is_locked():
 
247
            raise AssertionError()
 
248
        vf = self.revisions
 
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)
 
258
 
 
259
    def _check_for_inconsistent_revision_parents(self):
 
260
        inconsistencies = list(self._find_inconsistent_revision_parents())
 
261
        if inconsistencies:
 
262
            raise errors.BzrCheckError(
 
263
                "Revision knit has inconsistent parents.")
 
264
 
 
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.
 
268
        return True
 
269
 
 
270
 
 
271
class RepositoryFormatKnit(MetaDirRepositoryFormat):
 
272
    """Bzr repository knit format (generalized). 
 
273
 
 
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
 
282
     - a LockDir lock
 
283
    """
 
284
 
 
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
 
290
    # their constructor.
 
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
 
299
 
 
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)
 
306
 
 
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,
 
313
            annotated=False)
 
314
 
 
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,
 
321
            annotated=False)
 
322
 
 
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,
 
330
            annotated=True)
 
331
 
 
332
    def initialize(self, a_bzrdir, shared=False):
 
333
        """Create a knit format 1 repository.
 
334
 
 
335
        :param a_bzrdir: bzrdir to contain the new repository; must already
 
336
            be initialized.
 
337
        :param shared: If true the repository will be initialized as a shared
 
338
                       repository.
 
339
        """
 
340
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
341
        dirs = ['knits']
 
342
        files = []
 
343
        utf8_files = [('format', self.get_format_string())]
 
344
        
 
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)
 
351
        result.lock_write()
 
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',)])
 
357
        result.unlock()
 
358
        return result
 
359
 
 
360
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
361
        """See RepositoryFormat.open().
 
362
        
 
363
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
364
                                    repository at a slightly different url
 
365
                                    than normal. I.e. during 'upgrade'.
 
366
        """
 
367
        if not _found:
 
368
            format = RepositoryFormat.find_format(a_bzrdir)
 
369
        if _override_transport is not None:
 
370
            repo_transport = _override_transport
 
371
        else:
 
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,
 
376
                              a_bzrdir=a_bzrdir,
 
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
 
385
        return repo
 
386
 
 
387
 
 
388
class RepositoryFormatKnit1(RepositoryFormatKnit):
 
389
    """Bzr repository knit format 1.
 
390
 
 
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
 
399
     - a LockDir lock
 
400
 
 
401
    This format was introduced in bzr 0.8.
 
402
    """
 
403
 
 
404
    repository_class = KnitRepository
 
405
    _commit_builder_class = CommitBuilder
 
406
    _serializer = xml5.serializer_v5
 
407
 
 
408
    def __ne__(self, other):
 
409
        return self.__class__ is not other.__class__
 
410
 
 
411
    def get_format_string(self):
 
412
        """See RepositoryFormat.get_format_string()."""
 
413
        return "Bazaar-NG Knit Repository Format 1"
 
414
 
 
415
    def get_format_description(self):
 
416
        """See RepositoryFormat.get_format_description()."""
 
417
        return "Knit repository format 1"
 
418
 
 
419
    def check_conversion_target(self, target_format):
 
420
        pass
 
421
 
 
422
 
 
423
class RepositoryFormatKnit3(RepositoryFormatKnit):
 
424
    """Bzr repository knit format 3.
 
425
 
 
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
 
434
     - a LockDir lock
 
435
     - support for recording full info about the tree root
 
436
     - support for recording tree-references
 
437
    """
 
438
 
 
439
    repository_class = KnitRepository
 
440
    _commit_builder_class = RootCommitBuilder
 
441
    rich_root_data = True
 
442
    supports_tree_reference = True
 
443
    _serializer = xml7.serializer_v7
 
444
 
 
445
    def _get_matching_bzrdir(self):
 
446
        return bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
 
447
 
 
448
    def _ignore_setting_bzrdir(self, format):
 
449
        pass
 
450
 
 
451
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
452
 
 
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)
 
460
            
 
461
    def get_format_string(self):
 
462
        """See RepositoryFormat.get_format_string()."""
 
463
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
 
464
 
 
465
    def get_format_description(self):
 
466
        """See RepositoryFormat.get_format_description()."""
 
467
        return "Knit repository format 3"
 
468
 
 
469
 
 
470
class RepositoryFormatKnit4(RepositoryFormatKnit):
 
471
    """Bzr repository knit format 4.
 
472
 
 
473
    This repository format has everything in format 3, except for
 
474
    tree-references:
 
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
 
482
     - a LockDir lock
 
483
     - support for recording full info about the tree root
 
484
    """
 
485
 
 
486
    repository_class = KnitRepository
 
487
    _commit_builder_class = RootCommitBuilder
 
488
    rich_root_data = True
 
489
    supports_tree_reference = False
 
490
    _serializer = xml6.serializer_v6
 
491
 
 
492
    def _get_matching_bzrdir(self):
 
493
        return bzrdir.format_registry.make_bzrdir('rich-root')
 
494
 
 
495
    def _ignore_setting_bzrdir(self, format):
 
496
        pass
 
497
 
 
498
    _matchingbzrdir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
 
499
 
 
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)
 
504
 
 
505
    def get_format_string(self):
 
506
        """See RepositoryFormat.get_format_string()."""
 
507
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
 
508
 
 
509
    def get_format_description(self):
 
510
        """See RepositoryFormat.get_format_description()."""
 
511
        return "Knit repository format 4"