/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: 2018-05-06 11:48:54 UTC
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180506114854-h4qd9ojaqy8wxjsd
Move .mailmap to root.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/weave_fmt/bzrdir.py
18
18
 
19
19
from __future__ import absolute_import
20
20
 
21
 
from io import BytesIO
22
 
 
23
21
from ...bzr.bzrdir import (
24
22
    BzrDir,
25
23
    BzrDirFormat,
72
70
    fixed_components = True
73
71
 
74
72
    def initialize_on_transport_ex(self, transport, use_existing_dir=False,
75
 
                                   create_prefix=False, force_new_repo=False, stacked_on=None,
76
 
                                   stack_on_pwd=None, repo_format_name=None, make_working_trees=None,
77
 
                                   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):
78
76
        """See ControlDir.initialize_on_transport_ex."""
79
77
        require_stacking = (stacked_on is not None)
80
78
        # Format 5 cannot stack, but we've been asked to - actually init
82
80
        if require_stacking:
83
81
            format = BzrDirMetaFormat1()
84
82
            return format.initialize_on_transport_ex(transport,
85
 
                                                     use_existing_dir=use_existing_dir, create_prefix=create_prefix,
86
 
                                                     force_new_repo=force_new_repo, stacked_on=stacked_on,
87
 
                                                     stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
88
 
                                                     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)
89
87
        return BzrDirFormat.initialize_on_transport_ex(self, transport,
90
 
                                                       use_existing_dir=use_existing_dir, create_prefix=create_prefix,
91
 
                                                       force_new_repo=force_new_repo, stacked_on=stacked_on,
92
 
                                                       stack_on_pwd=stack_on_pwd, repo_format_name=repo_format_name,
93
 
                                                       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)
94
92
 
95
93
    @classmethod
96
94
    def from_string(cls, format_string):
246
244
        with ui.ui_factory.nested_progress_bar() as self.pb:
247
245
            ui.ui_factory.note(gettext('starting upgrade from format 4 to 5'))
248
246
            if isinstance(self.controldir.transport, local.LocalTransport):
249
 
                self.controldir.get_workingtree_transport(
250
 
                    None).delete('stat-cache')
 
247
                self.controldir.get_workingtree_transport(None).delete('stat-cache')
251
248
            self._convert_to_weaves()
252
249
            return ControlDir.open(self.controldir.user_url)
253
250
 
254
251
    def _convert_to_weaves(self):
255
252
        ui.ui_factory.note(gettext(
256
 
            'note: upgrade may be faster if all store files are ungzipped first'))
 
253
          'note: upgrade may be faster if all store files are ungzipped first'))
257
254
        try:
258
255
            # TODO permissions
259
256
            stat = self.controldir.transport.stat('weaves')
276
273
        self.to_read = rev_history[-1:]
277
274
        while self.to_read:
278
275
            rev_id = self.to_read.pop()
279
 
            if (rev_id not in self.revisions and
280
 
                    rev_id not in self.absent_revisions):
 
276
            if (rev_id not in self.revisions
 
277
                and rev_id not in self.absent_revisions):
281
278
                self._load_one_rev(rev_id)
282
279
        self.pb.clear()
283
280
        to_import = self._make_order()
289
286
        self._write_all_revs()
290
287
        ui.ui_factory.note(gettext('upgraded to weaves:'))
291
288
        ui.ui_factory.note('  ' + gettext('%6d revisions and inventories') %
292
 
                           len(self.revisions))
 
289
                                                        len(self.revisions))
293
290
        ui.ui_factory.note('  ' + gettext('%6d revisions not present') %
294
 
                           len(self.absent_revisions))
 
291
                                                    len(self.absent_revisions))
295
292
        ui.ui_factory.note('  ' + gettext('%6d texts') % self.text_count)
296
293
        self._cleanup_spare_files_after_format4()
297
294
        self.branch._transport.put_bytes(
312
309
 
313
310
    def _convert_working_inv(self):
314
311
        inv = xml4.serializer_v4.read_inventory(
315
 
            self.branch._transport.get('inventory'))
316
 
        f = BytesIO()
317
 
        xml5.serializer_v5.write_inventory(inv, f, working=True)
318
 
        self.branch._transport.put_bytes('inventory', f.getvalue(),
319
 
                                         mode=self.controldir._get_file_mode())
 
312
                self.branch._transport.get('inventory'))
 
313
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv, working=True)
 
314
        self.branch._transport.put_bytes('inventory', new_inv_xml,
 
315
            mode=self.controldir._get_file_mode())
320
316
 
321
317
    def _write_all_weaves(self):
322
318
        controlweaves = VersionedFileStore(self.controldir.transport, prefixed=False,
323
 
                                           versionedfile_class=weave.WeaveFile)
 
319
            versionedfile_class=weave.WeaveFile)
324
320
        weave_transport = self.controldir.transport.clone('weaves')
325
321
        weaves = VersionedFileStore(weave_transport, prefixed=False,
326
 
                                    versionedfile_class=weave.WeaveFile)
 
322
                versionedfile_class=weave.WeaveFile)
327
323
        transaction = WriteTransaction()
328
324
 
329
325
        try:
330
326
            i = 0
331
327
            for file_id, file_weave in self.text_weaves.items():
332
328
                self.pb.update(gettext('writing weave'), i,
333
 
                               len(self.text_weaves))
 
329
                                                        len(self.text_weaves))
334
330
                weaves._put_weave(file_id, file_weave, transaction)
335
331
                i += 1
336
332
            self.pb.update(gettext('inventory'), 0, 1)
337
 
            controlweaves._put_weave(b'inventory', self.inv_weave, transaction)
 
333
            controlweaves._put_weave('inventory', self.inv_weave, transaction)
338
334
            self.pb.update(gettext('inventory'), 1, 1)
339
335
        finally:
340
336
            self.pb.clear()
348
344
        from ...bzr.xml5 import serializer_v5
349
345
        from .repository import RevisionTextStore
350
346
        revision_store = RevisionTextStore(revision_transport,
351
 
                                           serializer_v5, False, versionedfile.PrefixMapper(),
352
 
                                           lambda: True, lambda: True)
 
347
            serializer_v5, False, versionedfile.PrefixMapper(),
 
348
            lambda:True, lambda:True)
353
349
        try:
354
350
            for i, rev_id in enumerate(self.converted_revs):
355
351
                self.pb.update(gettext('write revision'), i,
356
 
                               len(self.converted_revs))
357
 
                lines = serializer_v5.write_revision_to_lines(
 
352
                                                len(self.converted_revs))
 
353
                text = serializer_v5.write_revision_to_string(
358
354
                    self.revisions[rev_id])
359
355
                key = (rev_id,)
360
 
                revision_store.add_lines(key, None, lines)
 
356
                revision_store.add_lines(key, None, osutils.split_lines(text))
361
357
        finally:
362
358
            self.pb.clear()
363
359
 
372
368
        if not self.branch.repository.has_revision(rev_id):
373
369
            self.pb.clear()
374
370
            ui.ui_factory.note(gettext('revision {%s} not present in branch; '
375
 
                                       'will be converted as a ghost') %
376
 
                               rev_id)
 
371
                         'will be converted as a ghost') %
 
372
                         rev_id)
377
373
            self.absent_revisions.add(rev_id)
378
374
        else:
379
375
            rev = self.branch.repository.get_revision(rev_id)
383
379
            self.revisions[rev_id] = rev
384
380
 
385
381
    def _load_old_inventory(self, rev_id):
386
 
        with self.branch.repository.inventory_store.get(rev_id) as f:
387
 
            inv = xml4.serializer_v4.read_inventory(f)
 
382
        f = self.branch.repository.inventory_store.get(rev_id)
 
383
        try:
 
384
            old_inv_xml = f.read()
 
385
        finally:
 
386
            f.close()
 
387
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
388
388
        inv.revision_id = rev_id
389
389
        rev = self.revisions[rev_id]
390
390
        return inv
391
391
 
392
392
    def _load_updated_inventory(self, rev_id):
393
 
        inv_xml = self.inv_weave.get_lines(rev_id)
394
 
        inv = xml5.serializer_v5.read_inventory_from_lines(inv_xml, rev_id)
 
393
        inv_xml = self.inv_weave.get_text(rev_id)
 
394
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
395
395
        return inv
396
396
 
397
397
    def _convert_one_rev(self, rev_id):
405
405
        self.converted_revs.add(rev_id)
406
406
 
407
407
    def _store_new_inv(self, rev, inv, present_parents):
408
 
        new_inv_xml = xml5.serializer_v5.write_inventory_to_lines(inv)
409
 
        new_inv_sha1 = osutils.sha_strings(new_inv_xml)
 
408
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
 
409
        new_inv_sha1 = osutils.sha_string(new_inv_xml)
410
410
        self.inv_weave.add_lines(rev.revision_id,
411
411
                                 present_parents,
412
 
                                 new_inv_xml)
 
412
                                 new_inv_xml.splitlines(True))
413
413
        rev.inventory_sha1 = new_inv_sha1
414
414
 
415
415
    def _convert_revision_contents(self, rev, inv, present_parents):
441
441
        heads = graph.Graph(self).heads(parent_candiate_entries)
442
442
        # XXX: Note that this is unordered - and this is tolerable because
443
443
        # the previous code was also unordered.
444
 
        previous_entries = {head: parent_candiate_entries[head]
445
 
                            for head in heads}
 
444
        previous_entries = dict((head, parent_candiate_entries[head]) for head
 
445
            in heads)
446
446
        self.snapshot_ie(previous_entries, ie, w, rev_id)
447
447
 
448
448
    def get_parent_map(self, revision_ids):
449
449
        """See graph.StackedParentsProvider.get_parent_map"""
450
450
        return dict((revision_id, self.revisions[revision_id])
451
451
                    for revision_id in revision_ids
452
 
                    if revision_id in self.revisions)
 
452
                     if revision_id in self.revisions)
453
453
 
454
454
    def snapshot_ie(self, previous_revisions, ie, w, rev_id):
455
455
        # TODO: convert this logic, which is ~= snapshot to
465
465
                ie.revision = previous_ie.revision
466
466
                return
467
467
        if ie.has_text():
468
 
            with self.branch.repository._text_store.get(ie.text_id) as f:
 
468
            f = self.branch.repository._text_store.get(ie.text_id)
 
469
            try:
469
470
                file_lines = f.readlines()
 
471
            finally:
 
472
                f.close()
470
473
            w.add_lines(rev_id, previous_revisions, file_lines)
471
474
            self.text_count += 1
472
475
        else:
516
519
            store = TransportStore(store_transport, prefixed=True)
517
520
            for urlfilename in store_transport.list_dir('.'):
518
521
                filename = urlutils.unescape(urlfilename)
519
 
                if (filename.endswith(".weave")
520
 
                    or filename.endswith(".gz")
521
 
                        or filename.endswith(".sig")):
 
522
                if (filename.endswith(".weave") or
 
523
                    filename.endswith(".gz") or
 
524
                    filename.endswith(".sig")):
522
525
                    file_id, suffix = os.path.splitext(filename)
523
526
                else:
524
527
                    file_id = filename
525
528
                    suffix = ''
526
 
                new_name = store._mapper.map(
527
 
                    (file_id.encode('utf-8'),)) + suffix
 
529
                new_name = store._mapper.map((file_id,)) + suffix
528
530
                # FIXME keep track of the dirs made RBC 20060121
529
531
                try:
530
532
                    store_transport.move(filename, new_name)
531
 
                except errors.NoSuchFile:  # catches missing dirs strangely enough
 
533
                except errors.NoSuchFile: # catches missing dirs strangely enough
532
534
                    store_transport.mkdir(osutils.dirname(new_name))
533
535
                    store_transport.move(filename, new_name)
534
536
        self.controldir.transport.put_bytes(
547
549
        self.controldir = to_convert
548
550
        self.pb = ui.ui_factory.nested_progress_bar()
549
551
        self.count = 0
550
 
        self.total = 20  # the steps we know about
 
552
        self.total = 20 # the steps we know about
551
553
        self.garbage_inventories = []
552
554
        self.dir_mode = self.controldir._get_dir_mode()
553
555
        self.file_mode = self.controldir._get_file_mode()
554
556
 
555
 
        ui.ui_factory.note(
556
 
            gettext('starting upgrade from format 6 to metadir'))
 
557
        ui.ui_factory.note(gettext('starting upgrade from format 6 to metadir'))
557
558
        self.controldir.transport.put_bytes(
558
 
            'branch-format',
559
 
            b"Converting to format 6",
560
 
            mode=self.file_mode)
 
559
                'branch-format',
 
560
                "Converting to format 6",
 
561
                mode=self.file_mode)
561
562
        # its faster to move specific files around than to open and use the apis...
562
563
        # first off, nuke ancestry.weave, it was never used.
563
564
        try:
656
657
 
657
658
    def put_format(self, dirname, format):
658
659
        self.controldir.transport.put_bytes('%s/format' % dirname,
659
 
                                            format.get_format_string(),
660
 
                                            self.file_mode)
 
660
            format.get_format_string(),
 
661
            self.file_mode)
661
662
 
662
663
 
663
664
class BzrDirFormat4(BzrDirFormat):
732
733
        """See ControlDir.__init__."""
733
734
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
734
735
        self._control_files = lockable_files.LockableFiles(
735
 
            self.get_branch_transport(None),
736
 
            self._format._lock_file_name,
737
 
            self._format._lock_class)
 
736
                                            self.get_branch_transport(None),
 
737
                                            self._format._lock_file_name,
 
738
                                            self._format._lock_class)
738
739
 
739
740
    def break_lock(self):
740
741
        """Pre-splitout bzrdirs do not suffer from stale locks."""
747
748
        return self._format.__class__()
748
749
 
749
750
    def clone(self, url, revision_id=None, force_new_repo=False,
750
 
              preserve_stacking=False, tag_selector=None):
 
751
              preserve_stacking=False):
751
752
        """See ControlDir.clone().
752
753
 
753
754
        force_new_repo has no effect, since this family of formats always
759
760
        result = self._format._initialize_for_clone(url)
760
761
        self.open_repository().clone(result, revision_id=revision_id)
761
762
        from_branch = self.open_branch()
762
 
        from_branch.clone(result, revision_id=revision_id, tag_selector=tag_selector)
 
763
        from_branch.clone(result, revision_id=revision_id)
763
764
        try:
764
765
            tree = self.open_workingtree()
765
766
        except errors.NotLocalUrl:
776
777
            raise NotImplementedError(
777
778
                "create_branch(repository=<not None>) on %r" % (self,))
778
779
        return self._format.get_branch_format().initialize(self, name=name,
779
 
                                                           append_revisions_only=append_revisions_only)
 
780
            append_revisions_only=append_revisions_only)
780
781
 
781
782
    def destroy_branch(self, name=None):
782
783
        """See ControlDir.destroy_branch."""
809
810
        # done on this format anyway. So - acceptable wart.
810
811
        if hardlink:
811
812
            warning("can't support hardlinked working trees in %r"
812
 
                    % (self,))
 
813
                % (self,))
813
814
        try:
814
815
            result = self.open_workingtree(recommend_upgrade=False)
815
816
        except errors.NoSuchFile:
842
843
 
843
844
    def get_branch_transport(self, branch_format, name=None):
844
845
        """See BzrDir.get_branch_transport()."""
845
 
        if name:
 
846
        if name is not None:
846
847
            raise errors.NoColocatedBranchSupport(self)
847
848
        if branch_format is None:
848
849
            return self.transport
885
886
        format = BzrBranchFormat4()
886
887
        format.check_support_status(unsupported)
887
888
        return format.open(self, name, _found=True,
888
 
                           possible_transports=possible_transports)
 
889
            possible_transports=possible_transports)
889
890
 
890
891
    def sprout(self, url, revision_id=None, force_new_repo=False,
891
 
               recurse=None, possible_transports=None, accelerator_tree=None,
 
892
               possible_transports=None, accelerator_tree=None,
892
893
               hardlink=False, stacked=False, create_tree_if_local=True,
893
894
               source_branch=None):
894
895
        """See ControlDir.sprout()."""
958
959
    def has_workingtree(self):
959
960
        """See ControlDir.has_workingtree."""
960
961
        return True
961
 
 
 
962
    
962
963
    def open_repository(self):
963
964
        """See ControlDir.open_repository."""
964
965
        from .repository import RepositoryFormat5
965
966
        return RepositoryFormat5().open(self, _found=True)
966
967
 
967
968
    def open_workingtree(self, unsupported=False,
968
 
                         recommend_upgrade=True):
 
969
            recommend_upgrade=True):
969
970
        """See ControlDir.create_workingtree."""
970
971
        from .workingtree import WorkingTreeFormat2
971
972
        wt_format = WorkingTreeFormat2()