/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/bzrdir.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:
70
70
    fixed_components = True
71
71
 
72
72
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
73
 
        create_prefix=False, force_new_repo=False, stacked_on=None,
74
 
        stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
75
 
        shared_repo=False):
 
73
                                   create_prefix=False, force_new_repo=False, stacked_on=None,
 
74
                                   stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
 
75
                                   shared_repo=False):
76
76
        """See ControlDir.initialize_on_transport_ex."""
77
77
        require_stacking = (stacked_on is not None)
78
78
        # Format 5 cannot stack, but we've been asked to - actually init
80
80
        if require_stacking:
81
81
            format = BzrDirMetaFormat1()
82
82
            return format.initialize_on_transport_ex(transport,
83
 
                use_existing_dir=use_existing_dir, create_prefix=create_prefix,
84
 
                force_new_repo=force_new_repo, stacked_on=stacked_on,
85
 
                stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
86
 
                make_working_trees=make_working_trees, shared_repo=shared_repo)
 
83
                                                     use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
84
                                                     force_new_repo=force_new_repo, stacked_on=stacked_on,
 
85
                                                     stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
86
                                                     make_working_trees=make_working_trees, shared_repo=shared_repo)
87
87
        return BzrDirFormat.initialize_on_transport_ex(self, transport,
88
 
            use_existing_dir=use_existing_dir, create_prefix=create_prefix,
89
 
            force_new_repo=force_new_repo, stacked_on=stacked_on,
90
 
            stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
91
 
            make_working_trees=make_working_trees, shared_repo=shared_repo)
 
88
                                                       use_existing_dir=use_existing_dir, create_prefix=create_prefix,
 
89
                                                       force_new_repo=force_new_repo, stacked_on=stacked_on,
 
90
                                                       stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
 
91
                                                       make_working_trees=make_working_trees, shared_repo=shared_repo)
92
92
 
93
93
    @classmethod
94
94
    def from_string(cls, format_string):
244
244
        with ui.ui_factory.nested_progress_bar() as self.pb:
245
245
            ui.ui_factory.note(gettext('starting upgrade from format 4 to 5'))
246
246
            if isinstance(self.controldir.transport, local.LocalTransport):
247
 
                self.controldir.get_workingtree_transport(None).delete('stat-cache')
 
247
                self.controldir.get_workingtree_transport(
 
248
                    None).delete('stat-cache')
248
249
            self._convert_to_weaves()
249
250
            return ControlDir.open(self.controldir.user_url)
250
251
 
251
252
    def _convert_to_weaves(self):
252
253
        ui.ui_factory.note(gettext(
253
 
          'note: upgrade may be faster if all store files are ungzipped first'))
 
254
            'note: upgrade may be faster if all store files are ungzipped first'))
254
255
        try:
255
256
            # TODO permissions
256
257
            stat = self.controldir.transport.stat('weaves')
273
274
        self.to_read = rev_history[-1:]
274
275
        while self.to_read:
275
276
            rev_id = self.to_read.pop()
276
 
            if (rev_id not in self.revisions
277
 
                and rev_id not in self.absent_revisions):
 
277
            if (rev_id not in self.revisions and
 
278
                    rev_id not in self.absent_revisions):
278
279
                self._load_one_rev(rev_id)
279
280
        self.pb.clear()
280
281
        to_import = self._make_order()
286
287
        self._write_all_revs()
287
288
        ui.ui_factory.note(gettext('upgraded to weaves:'))
288
289
        ui.ui_factory.note('  ' + gettext('%6d revisions and inventories') %
289
 
                                                        len(self.revisions))
 
290
                           len(self.revisions))
290
291
        ui.ui_factory.note('  ' + gettext('%6d revisions not present') %
291
 
                                                    len(self.absent_revisions))
 
292
                           len(self.absent_revisions))
292
293
        ui.ui_factory.note('  ' + gettext('%6d texts') % self.text_count)
293
294
        self._cleanup_spare_files_after_format4()
294
295
        self.branch._transport.put_bytes(
309
310
 
310
311
    def _convert_working_inv(self):
311
312
        inv = xml4.serializer_v4.read_inventory(
312
 
                self.branch._transport.get('inventory'))
313
 
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
 
313
            self.branch._transport.get('inventory'))
 
314
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(
 
315
            inv, working=True)
314
316
        self.branch._transport.put_bytes('inventory', new_inv_xml,
315
 
            mode=self.controldir._get_file_mode())
 
317
                                         mode=self.controldir._get_file_mode())
316
318
 
317
319
    def _write_all_weaves(self):
318
320
        controlweaves = VersionedFileStore(self.controldir.transport, prefixed=False,
319
 
            versionedfile_class=weave.WeaveFile)
 
321
                                           versionedfile_class=weave.WeaveFile)
320
322
        weave_transport = self.controldir.transport.clone('weaves')
321
323
        weaves = VersionedFileStore(weave_transport, prefixed=False,
322
 
                versionedfile_class=weave.WeaveFile)
 
324
                                    versionedfile_class=weave.WeaveFile)
323
325
        transaction = WriteTransaction()
324
326
 
325
327
        try:
326
328
            i = 0
327
329
            for file_id, file_weave in self.text_weaves.items():
328
330
                self.pb.update(gettext('writing weave'), i,
329
 
                                                        len(self.text_weaves))
 
331
                               len(self.text_weaves))
330
332
                weaves._put_weave(file_id, file_weave, transaction)
331
333
                i += 1
332
334
            self.pb.update(gettext('inventory'), 0, 1)
344
346
        from ...bzr.xml5 import serializer_v5
345
347
        from .repository import RevisionTextStore
346
348
        revision_store = RevisionTextStore(revision_transport,
347
 
            serializer_v5, False, versionedfile.PrefixMapper(),
348
 
            lambda:True, lambda:True)
 
349
                                           serializer_v5, False, versionedfile.PrefixMapper(),
 
350
                                           lambda: True, lambda: True)
349
351
        try:
350
352
            for i, rev_id in enumerate(self.converted_revs):
351
353
                self.pb.update(gettext('write revision'), i,
352
 
                                                len(self.converted_revs))
 
354
                               len(self.converted_revs))
353
355
                text = serializer_v5.write_revision_to_string(
354
356
                    self.revisions[rev_id])
355
357
                key = (rev_id,)
368
370
        if not self.branch.repository.has_revision(rev_id):
369
371
            self.pb.clear()
370
372
            ui.ui_factory.note(gettext('revision {%s} not present in branch; '
371
 
                         'will be converted as a ghost') %
372
 
                         rev_id)
 
373
                                       'will be converted as a ghost') %
 
374
                               rev_id)
373
375
            self.absent_revisions.add(rev_id)
374
376
        else:
375
377
            rev = self.branch.repository.get_revision(rev_id)
449
451
        """See graph.StackedParentsProvider.get_parent_map"""
450
452
        return dict((revision_id, self.revisions[revision_id])
451
453
                    for revision_id in revision_ids
452
 
                     if revision_id in self.revisions)
 
454
                    if revision_id in self.revisions)
453
455
 
454
456
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
455
457
        # TODO: convert this logic, which is ~= snapshot to
519
521
            store = TransportStore(store_transport, prefixed=True)
520
522
            for urlfilename in store_transport.list_dir('.'):
521
523
                filename = urlutils.unescape(urlfilename)
522
 
                if (filename.endswith(".weave") or
523
 
                    filename.endswith(".gz") or
524
 
                    filename.endswith(".sig")):
 
524
                if (filename.endswith(".weave")
 
525
                    or filename.endswith(".gz")
 
526
                        or filename.endswith(".sig")):
525
527
                    file_id, suffix = os.path.splitext(filename)
526
528
                else:
527
529
                    file_id = filename
528
530
                    suffix = ''
529
 
                new_name = store._mapper.map((file_id.encode('utf-8'),)) + suffix
 
531
                new_name = store._mapper.map(
 
532
                    (file_id.encode('utf-8'),)) + suffix
530
533
                # FIXME keep track of the dirs made RBC 20060121
531
534
                try:
532
535
                    store_transport.move(filename, new_name)
533
 
                except errors.NoSuchFile: # catches missing dirs strangely enough
 
536
                except errors.NoSuchFile:  # catches missing dirs strangely enough
534
537
                    store_transport.mkdir(osutils.dirname(new_name))
535
538
                    store_transport.move(filename, new_name)
536
539
        self.controldir.transport.put_bytes(
549
552
        self.controldir = to_convert
550
553
        self.pb = ui.ui_factory.nested_progress_bar()
551
554
        self.count = 0
552
 
        self.total = 20 # the steps we know about
 
555
        self.total = 20  # the steps we know about
553
556
        self.garbage_inventories = []
554
557
        self.dir_mode = self.controldir._get_dir_mode()
555
558
        self.file_mode = self.controldir._get_file_mode()
556
559
 
557
 
        ui.ui_factory.note(gettext('starting upgrade from format 6 to metadir'))
 
560
        ui.ui_factory.note(
 
561
            gettext('starting upgrade from format 6 to metadir'))
558
562
        self.controldir.transport.put_bytes(
559
 
                'branch-format',
560
 
                b"Converting to format 6",
561
 
                mode=self.file_mode)
 
563
            'branch-format',
 
564
            b"Converting to format 6",
 
565
            mode=self.file_mode)
562
566
        # its faster to move specific files around than to open and use the apis...
563
567
        # first off, nuke ancestry.weave, it was never used.
564
568
        try:
657
661
 
658
662
    def put_format(self, dirname, format):
659
663
        self.controldir.transport.put_bytes('%s/format' % dirname,
660
 
            format.get_format_string(),
661
 
            self.file_mode)
 
664
                                            format.get_format_string(),
 
665
                                            self.file_mode)
662
666
 
663
667
 
664
668
class BzrDirFormat4(BzrDirFormat):
733
737
        """See ControlDir.__init__."""
734
738
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
735
739
        self._control_files = lockable_files.LockableFiles(
736
 
                                            self.get_branch_transport(None),
737
 
                                            self._format._lock_file_name,
738
 
                                            self._format._lock_class)
 
740
            self.get_branch_transport(None),
 
741
            self._format._lock_file_name,
 
742
            self._format._lock_class)
739
743
 
740
744
    def break_lock(self):
741
745
        """Pre-splitout bzrdirs do not suffer from stale locks."""
777
781
            raise NotImplementedError(
778
782
                "create_branch(repository=<not None>) on %r" % (self,))
779
783
        return self._format.get_branch_format().initialize(self, name=name,
780
 
            append_revisions_only=append_revisions_only)
 
784
                                                           append_revisions_only=append_revisions_only)
781
785
 
782
786
    def destroy_branch(self, name=None):
783
787
        """See ControlDir.destroy_branch."""
810
814
        # done on this format anyway. So - acceptable wart.
811
815
        if hardlink:
812
816
            warning("can't support hardlinked working trees in %r"
813
 
                % (self,))
 
817
                    % (self,))
814
818
        try:
815
819
            result = self.open_workingtree(recommend_upgrade=False)
816
820
        except errors.NoSuchFile:
886
890
        format = BzrBranchFormat4()
887
891
        format.check_support_status(unsupported)
888
892
        return format.open(self, name, _found=True,
889
 
            possible_transports=possible_transports)
 
893
                           possible_transports=possible_transports)
890
894
 
891
895
    def sprout(self, url, revision_id=None, force_new_repo=False,
892
896
               possible_transports=None, accelerator_tree=None,
959
963
    def has_workingtree(self):
960
964
        """See ControlDir.has_workingtree."""
961
965
        return True
962
 
    
 
966
 
963
967
    def open_repository(self):
964
968
        """See ControlDir.open_repository."""
965
969
        from .repository import RepositoryFormat5
966
970
        return RepositoryFormat5().open(self, _found=True)
967
971
 
968
972
    def open_workingtree(self, unsupported=False,
969
 
            recommend_upgrade=True):
 
973
                         recommend_upgrade=True):
970
974
        """See ControlDir.create_workingtree."""
971
975
        from .workingtree import WorkingTreeFormat2
972
976
        wt_format = WorkingTreeFormat2()