/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 breezy/bzr/knitrepo.py

  • Committer: Jelmer Vernooij
  • Date: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/bzr/knitrepo.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
from ..lazy_import import lazy_import
18
20
lazy_import(globals(), """
19
21
import itertools
20
22
 
21
23
from breezy import (
22
24
    controldir,
 
25
    errors,
23
26
    lockable_files,
24
27
    lockdir,
25
28
    osutils,
35
38
    xml7,
36
39
    )
37
40
""")
38
 
from .. import (
39
 
    errors,
40
 
    )
41
41
from ..repository import (
42
42
    InterRepository,
43
43
    IsInWriteGroupError,
50
50
    MetaDirVersionedFileRepository,
51
51
    MetaDirVersionedFileRepositoryFormat,
52
52
    VersionedFileCommitBuilder,
 
53
    VersionedFileRootCommitBuilder,
53
54
    )
54
55
 
55
56
 
121
122
    _serializer = None
122
123
 
123
124
    def __init__(self, _format, a_controldir, control_files, _commit_builder_class,
124
 
                 _serializer):
125
 
        super(KnitRepository, self).__init__(
126
 
            _format, a_controldir, control_files)
 
125
        _serializer):
 
126
        super(KnitRepository, self).__init__(_format, a_controldir, control_files)
127
127
        self._commit_builder_class = _commit_builder_class
128
128
        self._serializer = _serializer
129
129
        self._reconcile_fixes_text_parents = True
178
178
 
179
179
    def _temp_inventories(self):
180
180
        result = self._format._get_inventories(self._transport, self,
181
 
                                               'inventory.new')
 
181
            'inventory.new')
182
182
        # Reconciling when the output has no revisions would result in no
183
183
        # writes - but we want to ensure there is an inventory for
184
184
        # compatibility with older clients that don't lazy-load.
185
 
        result.get_parent_map([(b'A',)])
 
185
        result.get_parent_map([('A',)])
186
186
        return result
187
187
 
188
188
    def get_revision(self, revision_id):
189
189
        """Return the Revision object for a named revision"""
 
190
        revision_id = osutils.safe_revision_id(revision_id)
190
191
        with self.lock_read():
191
192
            return self.get_revision_reconcile(revision_id)
192
193
 
205
206
 
206
207
    def reconcile(self, other=None, thorough=False):
207
208
        """Reconcile this repository."""
208
 
        from .reconcile import KnitReconciler
 
209
        from breezy.reconcile import KnitReconciler
209
210
        with self.lock_write():
210
211
            reconciler = KnitReconciler(self, thorough=thorough)
211
 
            return reconciler.reconcile()
 
212
            reconciler.reconcile()
 
213
            return reconciler
212
214
 
213
215
    def _make_parents_provider(self):
214
216
        return _KnitsParentsProvider(self.revisions)
237
239
    _commit_builder_class = None
238
240
    # Set this attribute in derived clases to control the _serializer that the
239
241
    # repository objects will have passed to their constructor.
240
 
 
241
242
    @property
242
243
    def _serializer(self):
243
244
        return xml5.serializer_v5
258
259
    def _get_inventories(self, repo_transport, repo, name='inventory'):
259
260
        mapper = versionedfile.ConstantMapper(name)
260
261
        index = _mod_knit._KndxIndex(repo_transport, mapper,
261
 
                                     repo.get_transaction, repo.is_write_locked, repo.is_locked)
 
262
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
262
263
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
263
264
        return _mod_knit.KnitVersionedFiles(index, access, annotated=False)
264
265
 
265
266
    def _get_revisions(self, repo_transport, repo):
266
267
        mapper = versionedfile.ConstantMapper('revisions')
267
268
        index = _mod_knit._KndxIndex(repo_transport, mapper,
268
 
                                     repo.get_transaction, repo.is_write_locked, repo.is_locked)
 
269
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
269
270
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
270
271
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
271
 
                                            annotated=False)
 
272
            annotated=False)
272
273
 
273
274
    def _get_signatures(self, repo_transport, repo):
274
275
        mapper = versionedfile.ConstantMapper('signatures')
275
276
        index = _mod_knit._KndxIndex(repo_transport, mapper,
276
 
                                     repo.get_transaction, repo.is_write_locked, repo.is_locked)
 
277
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
277
278
        access = _mod_knit._KnitKeyAccess(repo_transport, mapper)
278
279
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=0,
279
 
                                            annotated=False)
 
280
            annotated=False)
280
281
 
281
282
    def _get_texts(self, repo_transport, repo):
282
283
        mapper = versionedfile.HashEscapedPrefixMapper()
283
284
        base_transport = repo_transport.clone('knits')
284
285
        index = _mod_knit._KndxIndex(base_transport, mapper,
285
 
                                     repo.get_transaction, repo.is_write_locked, repo.is_locked)
 
286
            repo.get_transaction, repo.is_write_locked, repo.is_locked)
286
287
        access = _mod_knit._KnitKeyAccess(base_transport, mapper)
287
288
        return _mod_knit.KnitVersionedFiles(index, access, max_delta_chain=200,
288
 
                                            annotated=True)
 
289
            annotated=True)
289
290
 
290
291
    def initialize(self, a_controldir, shared=False):
291
292
        """Create a knit format 1 repository.
300
301
        files = []
301
302
        utf8_files = [('format', self.get_format_string())]
302
303
 
303
 
        self._upload_blank_content(
304
 
            a_controldir, dirs, files, utf8_files, shared)
 
304
        self._upload_blank_content(a_controldir, dirs, files, utf8_files, shared)
305
305
        repo_transport = a_controldir.get_repository_transport(None)
306
306
        control_files = lockable_files.LockableFiles(repo_transport,
307
 
                                                     'lock', lockdir.LockDir)
 
307
                                'lock', lockdir.LockDir)
308
308
        transaction = transactions.WriteTransaction()
309
309
        result = self.open(a_controldir=a_controldir, _found=True)
310
310
        result.lock_write()
311
311
        # the revision id here is irrelevant: it will not be stored, and cannot
312
312
        # already exist, we do this to create files on disk for older clients.
313
 
        result.inventories.get_parent_map([(b'A',)])
314
 
        result.revisions.get_parent_map([(b'A',)])
315
 
        result.signatures.get_parent_map([(b'A',)])
 
313
        result.inventories.get_parent_map([('A',)])
 
314
        result.revisions.get_parent_map([('A',)])
 
315
        result.signatures.get_parent_map([('A',)])
316
316
        result.unlock()
317
317
        self._run_post_repo_init_hooks(result, a_controldir, shared)
318
318
        return result
331
331
        else:
332
332
            repo_transport = a_controldir.get_repository_transport(None)
333
333
        control_files = lockable_files.LockableFiles(repo_transport,
334
 
                                                     'lock', lockdir.LockDir)
 
334
                                'lock', lockdir.LockDir)
335
335
        repo = self.repository_class(_format=self,
336
 
                                     a_controldir=a_controldir,
337
 
                                     control_files=control_files,
338
 
                                     _commit_builder_class=self._commit_builder_class,
339
 
                                     _serializer=self._serializer)
 
336
                              a_controldir=a_controldir,
 
337
                              control_files=control_files,
 
338
                              _commit_builder_class=self._commit_builder_class,
 
339
                              _serializer=self._serializer)
340
340
        repo.revisions = self._get_revisions(repo_transport, repo)
341
341
        repo.signatures = self._get_signatures(repo_transport, repo)
342
342
        repo.inventories = self._get_inventories(repo_transport, repo)
364
364
 
365
365
    repository_class = KnitRepository
366
366
    _commit_builder_class = VersionedFileCommitBuilder
367
 
 
368
367
    @property
369
368
    def _serializer(self):
370
369
        return xml5.serializer_v5
375
374
    @classmethod
376
375
    def get_format_string(cls):
377
376
        """See RepositoryFormat.get_format_string()."""
378
 
        return b"Bazaar-NG Knit Repository Format 1"
 
377
        return "Bazaar-NG Knit Repository Format 1"
379
378
 
380
379
    def get_format_description(self):
381
380
        """See RepositoryFormat.get_format_description()."""
399
398
    """
400
399
 
401
400
    repository_class = KnitRepository
402
 
    _commit_builder_class = VersionedFileCommitBuilder
 
401
    _commit_builder_class = VersionedFileRootCommitBuilder
403
402
    rich_root_data = True
404
403
    experimental = True
405
404
    supports_tree_reference = True
406
 
 
407
405
    @property
408
406
    def _serializer(self):
409
407
        return xml7.serializer_v7
414
412
    def _ignore_setting_bzrdir(self, format):
415
413
        pass
416
414
 
417
 
    _matchingcontroldir = property(
418
 
        _get_matching_bzrdir, _ignore_setting_bzrdir)
 
415
    _matchingcontroldir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
419
416
 
420
417
    @classmethod
421
418
    def get_format_string(cls):
422
419
        """See RepositoryFormat.get_format_string()."""
423
 
        return b"Bazaar Knit Repository Format 3 (bzr 0.15)\n"
 
420
        return "Bazaar Knit Repository Format 3 (bzr 0.15)\n"
424
421
 
425
422
    def get_format_description(self):
426
423
        """See RepositoryFormat.get_format_description()."""
444
441
    """
445
442
 
446
443
    repository_class = KnitRepository
447
 
    _commit_builder_class = VersionedFileCommitBuilder
 
444
    _commit_builder_class = VersionedFileRootCommitBuilder
448
445
    rich_root_data = True
449
446
    supports_tree_reference = False
450
 
 
451
447
    @property
452
448
    def _serializer(self):
453
449
        return xml6.serializer_v6
458
454
    def _ignore_setting_bzrdir(self, format):
459
455
        pass
460
456
 
461
 
    _matchingcontroldir = property(
462
 
        _get_matching_bzrdir, _ignore_setting_bzrdir)
 
457
    _matchingcontroldir = property(_get_matching_bzrdir, _ignore_setting_bzrdir)
463
458
 
464
459
    @classmethod
465
460
    def get_format_string(cls):
466
461
        """See RepositoryFormat.get_format_string()."""
467
 
        return b'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
 
462
        return 'Bazaar Knit Repository Format 4 (bzr 1.0)\n'
468
463
 
469
464
    def get_format_description(self):
470
465
        """See RepositoryFormat.get_format_description()."""
487
482
        overly general.
488
483
        """
489
484
        try:
490
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit)
491
 
                         and isinstance(target._format, RepositoryFormatKnit))
 
485
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
 
486
                isinstance(target._format, RepositoryFormatKnit))
492
487
        except AttributeError:
493
488
            return False
494
489
        return are_knits and InterRepository._same_model(source, target)
495
490
 
496
491
    def search_missing_revision_ids(self,
497
 
                                    find_ghosts=True, revision_ids=None, if_present_ids=None,
498
 
                                    limit=None):
 
492
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
493
            limit=None):
499
494
        """See InterRepository.search_missing_revision_ids()."""
500
495
        with self.lock_read():
501
496
            source_ids_set = self._present_source_revisions_for(
505
500
            # have in target, but don't try to check for existence where we know
506
501
            # we do not have a revision as that would be pointless.
507
502
            target_ids = set(self.target.all_revision_ids())
508
 
            possibly_present_revisions = target_ids.intersection(
509
 
                source_ids_set)
 
503
            possibly_present_revisions = target_ids.intersection(source_ids_set)
510
504
            actually_present_revisions = set(
511
505
                self.target._eliminate_revisions_not_present(possibly_present_revisions))
512
 
            required_revisions = source_ids_set.difference(
513
 
                actually_present_revisions)
 
506
            required_revisions = source_ids_set.difference(actually_present_revisions)
514
507
            if revision_ids is not None:
515
508
                # we used get_ancestry to determine source_ids then we are assured all
516
509
                # revisions referenced are present as they are installed in topological order.