/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/plugins/weave_fmt/repository.py

  • Committer: Jelmer Vernooij
  • Date: 2019-03-04 00:16:27 UTC
  • mfrom: (7293 work)
  • mto: This revision was merged to the branch mainline in revision 7318.
  • Revision ID: jelmer@jelmer.uk-20190304001627-v6u7o6pf97tukhek
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/weave_fmt/repository.py
118
118
            # which allows access to this old info.
119
119
            self.inventory_store = get_store('inventory-store')
120
120
            self._text_store = get_store('text-store')
121
 
        super(AllInOneRepository, self).__init__(_format, a_controldir, a_controldir._control_files)
 
121
        super(AllInOneRepository, self).__init__(
 
122
            _format, a_controldir, a_controldir._control_files)
122
123
 
123
124
    def _all_possible_ids(self):
124
125
        """Return all the possible revisions that we could find."""
161
162
                           revision_id=None, lossy=False):
162
163
        self._check_ascii_revisionid(revision_id, self.get_commit_builder)
163
164
        result = VersionedFileCommitBuilder(self, parents, config, timestamp,
164
 
            timezone, committer, revprops, revision_id, lossy=lossy)
 
165
                                            timezone, committer, revprops, revision_id, lossy=lossy)
165
166
        self.start_write_group()
166
167
        return result
167
168
 
168
169
    def _inventory_add_lines(self, revision_id, parents, lines,
169
 
        check_content=True):
 
170
                             check_content=True):
170
171
        """Store lines in inv_vf and return the sha1 of the inventory."""
171
172
        present_parents = self.get_graph().get_parent_map(parents)
172
173
        final_parents = []
174
175
            if parent in present_parents:
175
176
                final_parents.append((parent,))
176
177
        return self.inventories.add_lines((revision_id,), final_parents, lines,
177
 
            check_content=check_content)[0]
 
178
                                          check_content=check_content)[0]
178
179
 
179
180
    def is_shared(self):
180
181
        """AllInOne repositories cannot be shared."""
201
202
 
202
203
    def __init__(self, _format, a_controldir, control_files):
203
204
        super(WeaveMetaDirRepository, self).__init__(
204
 
                _format, a_controldir, control_files)
 
205
            _format, a_controldir, control_files)
205
206
        self._serializer = _format._serializer
206
207
 
207
208
    def _all_possible_ids(self):
245
246
                           revision_id=None, lossy=False):
246
247
        self._check_ascii_revisionid(revision_id, self.get_commit_builder)
247
248
        result = VersionedFileCommitBuilder(self, parents, config, timestamp,
248
 
            timezone, committer, revprops, revision_id, lossy=lossy)
 
249
                                            timezone, committer, revprops, revision_id, lossy=lossy)
249
250
        self.start_write_group()
250
251
        return result
251
252
 
255
256
            return self.get_revision_reconcile(revision_id)
256
257
 
257
258
    def _inventory_add_lines(self, revision_id, parents, lines,
258
 
        check_content=True):
 
259
                             check_content=True):
259
260
        """Store lines in inv_vf and return the sha1 of the inventory."""
260
261
        present_parents = self.get_graph().get_parent_map(parents)
261
262
        final_parents = []
263
264
            if parent in present_parents:
264
265
                final_parents.append((parent,))
265
266
        return self.inventories.add_lines((revision_id,), final_parents, lines,
266
 
            check_content=check_content)[0]
 
267
                                          check_content=check_content)[0]
267
268
 
268
269
 
269
270
class PreSplitOutRepositoryFormat(VersionedFileRepositoryFormat):
303
304
        # FIXME: RBC 20060125 don't peek under the covers
304
305
        # NB: no need to escape relative paths that are url safe.
305
306
        control_files = lockable_files.LockableFiles(a_controldir.transport,
306
 
            'branch-lock', lockable_files.TransportLock)
 
307
                                                     'branch-lock', lockable_files.TransportLock)
307
308
        control_files.create_lock()
308
309
        control_files.lock_write()
309
310
        transport = a_controldir.transport
312
313
                            mode=a_controldir._get_dir_mode())
313
314
            transport.mkdir('weaves', mode=a_controldir._get_dir_mode())
314
315
            transport.put_bytes_non_atomic('inventory.weave', empty_weave,
315
 
                mode=a_controldir._get_file_mode())
 
316
                                           mode=a_controldir._get_file_mode())
316
317
        finally:
317
318
            control_files.unlock()
318
319
        repository = self.open(a_controldir, _found=True)
378
379
    def _get_revisions(self, repo_transport, repo):
379
380
        from .xml4 import serializer_v4
380
381
        return RevisionTextStore(repo_transport.clone('revision-store'),
381
 
            serializer_v4, True, versionedfile.PrefixMapper(),
382
 
            repo.is_locked, repo.is_write_locked)
 
382
                                 serializer_v4, True, versionedfile.PrefixMapper(),
 
383
                                 repo.is_locked, repo.is_write_locked)
383
384
 
384
385
    def _get_signatures(self, repo_transport, repo):
385
386
        return SignatureTextStore(repo_transport.clone('revision-store'),
386
 
            False, versionedfile.PrefixMapper(),
387
 
            repo.is_locked, repo.is_write_locked)
 
387
                                  False, versionedfile.PrefixMapper(),
 
388
                                  repo.is_locked, repo.is_write_locked)
388
389
 
389
390
    def _get_texts(self, repo_transport, repo):
390
391
        return None
418
419
    def _get_inventories(self, repo_transport, repo, name='inventory'):
419
420
        mapper = versionedfile.ConstantMapper(name)
420
421
        return versionedfile.ThunkedVersionedFiles(repo_transport,
421
 
            weave.WeaveFile, mapper, repo.is_locked)
 
422
                                                   weave.WeaveFile, mapper, repo.is_locked)
422
423
 
423
424
    def _get_revisions(self, repo_transport, repo):
424
425
        return RevisionTextStore(repo_transport.clone('revision-store'),
425
 
            xml5.serializer_v5, False, versionedfile.PrefixMapper(),
426
 
            repo.is_locked, repo.is_write_locked)
 
426
                                 xml5.serializer_v5, False, versionedfile.PrefixMapper(),
 
427
                                 repo.is_locked, repo.is_write_locked)
427
428
 
428
429
    def _get_signatures(self, repo_transport, repo):
429
430
        return SignatureTextStore(repo_transport.clone('revision-store'),
430
 
            False, versionedfile.PrefixMapper(),
431
 
            repo.is_locked, repo.is_write_locked)
 
431
                                  False, versionedfile.PrefixMapper(),
 
432
                                  repo.is_locked, repo.is_write_locked)
432
433
 
433
434
    def _get_texts(self, repo_transport, repo):
434
435
        mapper = versionedfile.PrefixMapper()
435
436
        base_transport = repo_transport.clone('weaves')
436
437
        return versionedfile.ThunkedVersionedFiles(base_transport,
437
 
            weave.WeaveFile, mapper, repo.is_locked)
 
438
                                                   weave.WeaveFile, mapper, repo.is_locked)
438
439
 
439
440
 
440
441
class RepositoryFormat6(PreSplitOutRepositoryFormat):
449
450
    _versionedfile_class = weave.WeaveFile
450
451
    _matchingcontroldir = weave_bzrdir.BzrDirFormat6()
451
452
    supports_funky_characters = False
 
453
 
452
454
    @property
453
455
    def _serializer(self):
454
456
        return xml5.serializer_v5
464
466
    def _get_inventories(self, repo_transport, repo, name='inventory'):
465
467
        mapper = versionedfile.ConstantMapper(name)
466
468
        return versionedfile.ThunkedVersionedFiles(repo_transport,
467
 
            weave.WeaveFile, mapper, repo.is_locked)
 
469
                                                   weave.WeaveFile, mapper, repo.is_locked)
468
470
 
469
471
    def _get_revisions(self, repo_transport, repo):
470
472
        return RevisionTextStore(repo_transport.clone('revision-store'),
471
 
            xml5.serializer_v5, False, versionedfile.HashPrefixMapper(),
472
 
            repo.is_locked, repo.is_write_locked)
 
473
                                 xml5.serializer_v5, False, versionedfile.HashPrefixMapper(),
 
474
                                 repo.is_locked, repo.is_write_locked)
473
475
 
474
476
    def _get_signatures(self, repo_transport, repo):
475
477
        return SignatureTextStore(repo_transport.clone('revision-store'),
476
 
            False, versionedfile.HashPrefixMapper(),
477
 
            repo.is_locked, repo.is_write_locked)
 
478
                                  False, versionedfile.HashPrefixMapper(),
 
479
                                  repo.is_locked, repo.is_write_locked)
478
480
 
479
481
    def _get_texts(self, repo_transport, repo):
480
482
        mapper = versionedfile.HashPrefixMapper()
481
483
        base_transport = repo_transport.clone('weaves')
482
484
        return versionedfile.ThunkedVersionedFiles(base_transport,
483
 
            weave.WeaveFile, mapper, repo.is_locked)
 
485
                                                   weave.WeaveFile, mapper, repo.is_locked)
484
486
 
485
487
 
486
488
class RepositoryFormat7(MetaDirVersionedFileRepositoryFormat):
504
506
    _fetch_order = 'topological'
505
507
    _fetch_reconcile = True
506
508
    fast_deltas = False
 
509
 
507
510
    @property
508
511
    def _serializer(self):
509
512
        return xml5.serializer_v5
520
523
    def _get_inventories(self, repo_transport, repo, name='inventory'):
521
524
        mapper = versionedfile.ConstantMapper(name)
522
525
        return versionedfile.ThunkedVersionedFiles(repo_transport,
523
 
            weave.WeaveFile, mapper, repo.is_locked)
 
526
                                                   weave.WeaveFile, mapper, repo.is_locked)
524
527
 
525
528
    def _get_revisions(self, repo_transport, repo):
526
529
        return RevisionTextStore(repo_transport.clone('revision-store'),
527
 
            xml5.serializer_v5, True, versionedfile.HashPrefixMapper(),
528
 
            repo.is_locked, repo.is_write_locked)
 
530
                                 xml5.serializer_v5, True, versionedfile.HashPrefixMapper(),
 
531
                                 repo.is_locked, repo.is_write_locked)
529
532
 
530
533
    def _get_signatures(self, repo_transport, repo):
531
534
        return SignatureTextStore(repo_transport.clone('revision-store'),
532
 
            True, versionedfile.HashPrefixMapper(),
533
 
            repo.is_locked, repo.is_write_locked)
 
535
                                  True, versionedfile.HashPrefixMapper(),
 
536
                                  repo.is_locked, repo.is_write_locked)
534
537
 
535
538
    def _get_texts(self, repo_transport, repo):
536
539
        mapper = versionedfile.HashPrefixMapper()
537
540
        base_transport = repo_transport.clone('weaves')
538
541
        return versionedfile.ThunkedVersionedFiles(base_transport,
539
 
            weave.WeaveFile, mapper, repo.is_locked)
 
542
                                                   weave.WeaveFile, mapper, repo.is_locked)
540
543
 
541
544
    def initialize(self, a_controldir, shared=False):
542
545
        """Create a weave repository.
555
558
                 ]
556
559
        utf8_files = [('format', self.get_format_string())]
557
560
 
558
 
        self._upload_blank_content(a_controldir, dirs, files, utf8_files, shared)
 
561
        self._upload_blank_content(
 
562
            a_controldir, dirs, files, utf8_files, shared)
559
563
        return self.open(a_controldir=a_controldir, _found=True)
560
564
 
561
565
    def open(self, a_controldir, _found=False, _override_transport=None):
572
576
        else:
573
577
            repo_transport = a_controldir.get_repository_transport(None)
574
578
        control_files = lockable_files.LockableFiles(repo_transport,
575
 
                                'lock', lockdir.LockDir)
 
579
                                                     'lock', lockdir.LockDir)
576
580
        result = WeaveMetaDirRepository(_format=self, a_controldir=a_controldir,
577
 
            control_files=control_files)
 
581
                                        control_files=control_files)
578
582
        result.revisions = self._get_revisions(repo_transport, result)
579
583
        result.signatures = self._get_signatures(repo_transport, result)
580
584
        result.inventories = self._get_inventories(repo_transport, result)
614
618
            chunks = tuned_gzip.chunks_to_gzip(chunks)
615
619
        path = self._map(key)
616
620
        self._transport.put_file_non_atomic(
617
 
                path, BytesIO(b''.join(chunks)),
618
 
                create_parent_dir=True)
 
621
            path, BytesIO(b''.join(chunks)),
 
622
            create_parent_dir=True)
619
623
 
620
624
    def insert_record_stream(self, stream):
621
625
        adapters = {}
626
630
            # adapt to non-tuple interface
627
631
            if record.storage_kind == 'fulltext':
628
632
                self.add_lines(record.key, None,
629
 
                    osutils.split_lines(record.get_bytes_as('fulltext')))
 
633
                               osutils.split_lines(record.get_bytes_as('fulltext')))
630
634
            else:
631
635
                adapter_key = record.storage_kind, 'fulltext'
632
636
                try:
672
676
    """Legacy thunk for format 4 repositories."""
673
677
 
674
678
    def __init__(self, transport, serializer, compressed, mapper, is_locked,
675
 
        can_write):
 
679
                 can_write):
676
680
        """Create a RevisionTextStore at transport with serializer."""
677
681
        TextVersionedFiles.__init__(self, transport, compressed, mapper,
678
 
            is_locked, can_write)
 
682
                                    is_locked, can_write)
679
683
        self._serializer = serializer
680
684
 
681
685
    def _load_text_parents(self, key):
729
733
 
730
734
    def __init__(self, transport, compressed, mapper, is_locked, can_write):
731
735
        TextVersionedFiles.__init__(self, transport, compressed, mapper,
732
 
            is_locked, can_write)
 
736
                                    is_locked, can_write)
733
737
        self._ext = '.sig' + self._ext
734
738
 
735
739
    def get_parent_map(self, keys):
784
788
        try:
785
789
            return (isinstance(source._format, (RepositoryFormat5,
786
790
                                                RepositoryFormat6,
787
 
                                                RepositoryFormat7)) and
788
 
                    isinstance(target._format, (RepositoryFormat5,
789
 
                                                RepositoryFormat6,
790
 
                                                RepositoryFormat7)))
 
791
                                                RepositoryFormat7))
 
792
                    and isinstance(target._format, (RepositoryFormat5,
 
793
                                                    RepositoryFormat6,
 
794
                                                    RepositoryFormat7)))
791
795
        except AttributeError:
792
796
            return False
793
797
 
796
800
        with self.lock_write():
797
801
            # weave specific optimised path:
798
802
            try:
799
 
                self.target.set_make_working_trees(self.source.make_working_trees())
 
803
                self.target.set_make_working_trees(
 
804
                    self.source.make_working_trees())
800
805
            except (errors.RepositoryUpgradeRequired, NotImplementedError):
801
806
                pass
802
807
            # FIXME do not peek!
843
848
            # know we do not have a revision as that would be pointless.
844
849
            target_ids = set(self.target._all_possible_ids())
845
850
            possibly_present_revisions = target_ids.intersection(
846
 
                    source_ids_set)
 
851
                source_ids_set)
847
852
            actually_present_revisions = set(
848
853
                self.target._eliminate_revisions_not_present(
849
854
                    possibly_present_revisions))
850
855
            required_revisions = source_ids_set.difference(
851
 
                    actually_present_revisions)
 
856
                actually_present_revisions)
852
857
            if revision_ids is not None:
853
858
                # we used get_ancestry to determine source_ids then we are
854
859
                # assured all revisions referenced are present as they are
874
879
def get_extra_interrepo_test_combinations():
875
880
    from ...bzr import knitrepo
876
881
    return [(InterRepository, RepositoryFormat5(),
877
 
        knitrepo.RepositoryFormatKnit3())]
 
882
             knitrepo.RepositoryFormatKnit3())]