← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repofmt/weaverepo.py

(gz) Backslash escape selftest output when printing to non-unicode consoles
 (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/weaverepo.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2007-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
29
29
from bzrlib import (
30
30
    xml5,
31
31
    graph as _mod_graph,
 
32
    ui,
32
33
    )
33
34
""")
34
35
from bzrlib import (
38
39
    lockable_files,
39
40
    lockdir,
40
41
    osutils,
41
 
    revision as _mod_revision,
 
42
    trace,
42
43
    urlutils,
43
44
    versionedfile,
44
45
    weave,
47
48
from bzrlib.decorators import needs_read_lock, needs_write_lock
48
49
from bzrlib.repository import (
49
50
    CommitBuilder,
 
51
    InterRepository,
 
52
    InterSameDataRepository,
50
53
    MetaDirVersionedFileRepository,
51
54
    MetaDirRepositoryFormat,
52
55
    Repository,
53
56
    RepositoryFormat,
54
57
    )
55
58
from bzrlib.store.text import TextStore
56
 
from bzrlib.trace import mutter
57
59
from bzrlib.tuned_gzip import GzipFile, bytes_to_gzip
58
60
from bzrlib.versionedfile import (
59
61
    AbsentContentFactory,
106
108
    def _all_possible_ids(self):
107
109
        """Return all the possible revisions that we could find."""
108
110
        if 'evil' in debug.debug_flags:
109
 
            mutter_callsite(3, "_all_possible_ids scales with size of history.")
 
111
            trace.mutter_callsite(
 
112
                3, "_all_possible_ids scales with size of history.")
110
113
        return [key[-1] for key in self.inventories.keys()]
111
114
 
112
115
    @needs_read_lock
176
179
        :param new_value: True to restore the default, False to disable making
177
180
                          working trees.
178
181
        """
179
 
        raise errors.RepositoryUpgradeRequired(self.bzrdir.root_transport.base)
 
182
        raise errors.RepositoryUpgradeRequired(self.user_url)
180
183
 
181
184
    def make_working_trees(self):
182
185
        """Returns the policy for making working trees on new branches."""
199
202
    def _all_possible_ids(self):
200
203
        """Return all the possible revisions that we could find."""
201
204
        if 'evil' in debug.debug_flags:
202
 
            mutter_callsite(3, "_all_possible_ids scales with size of history.")
 
205
            trace.mutter_callsite(
 
206
                3, "_all_possible_ids scales with size of history.")
203
207
        return [key[-1] for key in self.inventories.keys()]
204
208
 
205
209
    @needs_read_lock
286
290
        weavefile.write_weave_v5(weave.Weave(), sio)
287
291
        empty_weave = sio.getvalue()
288
292
 
289
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
293
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
290
294
 
291
295
        # FIXME: RBC 20060125 don't peek under the covers
292
296
        # NB: no need to escape relative paths that are url safe.
302
306
                mode=a_bzrdir._get_file_mode())
303
307
        finally:
304
308
            control_files.unlock()
305
 
        return self.open(a_bzrdir, _found=True)
 
309
        repository = self.open(a_bzrdir, _found=True)
 
310
        self._run_post_repo_init_hooks(repository, a_bzrdir, shared)
 
311
        return repository
306
312
 
307
313
    def open(self, a_bzrdir, _found=False):
308
314
        """See RepositoryFormat.open()."""
524
530
        weavefile.write_weave_v5(weave.Weave(), sio)
525
531
        empty_weave = sio.getvalue()
526
532
 
527
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
533
        trace.mutter('creating repository in %s.', a_bzrdir.transport.base)
528
534
        dirs = ['revision-store', 'weaves']
529
535
        files = [('inventory.weave', StringIO(empty_weave)),
530
536
                 ]
734
740
        paths = list(relpaths)
735
741
        return set([self._mapper.unmap(path) for path in paths])
736
742
 
 
743
 
 
744
class InterWeaveRepo(InterSameDataRepository):
 
745
    """Optimised code paths between Weave based repositories.
 
746
 
 
747
    This should be in bzrlib/repofmt/weaverepo.py but we have not yet
 
748
    implemented lazy inter-object optimisation.
 
749
    """
 
750
 
 
751
    @classmethod
 
752
    def _get_repo_format_to_test(self):
 
753
        return RepositoryFormat7()
 
754
 
 
755
    @staticmethod
 
756
    def is_compatible(source, target):
 
757
        """Be compatible with known Weave formats.
 
758
 
 
759
        We don't test for the stores being of specific types because that
 
760
        could lead to confusing results, and there is no need to be
 
761
        overly general.
 
762
        """
 
763
        try:
 
764
            return (isinstance(source._format, (RepositoryFormat5,
 
765
                                                RepositoryFormat6,
 
766
                                                RepositoryFormat7)) and
 
767
                    isinstance(target._format, (RepositoryFormat5,
 
768
                                                RepositoryFormat6,
 
769
                                                RepositoryFormat7)))
 
770
        except AttributeError:
 
771
            return False
 
772
 
 
773
    @needs_write_lock
 
774
    def copy_content(self, revision_id=None):
 
775
        """See InterRepository.copy_content()."""
 
776
        # weave specific optimised path:
 
777
        try:
 
778
            self.target.set_make_working_trees(self.source.make_working_trees())
 
779
        except (errors.RepositoryUpgradeRequired, NotImplemented):
 
780
            pass
 
781
        # FIXME do not peek!
 
782
        if self.source._transport.listable():
 
783
            pb = ui.ui_factory.nested_progress_bar()
 
784
            try:
 
785
                self.target.texts.insert_record_stream(
 
786
                    self.source.texts.get_record_stream(
 
787
                        self.source.texts.keys(), 'topological', False))
 
788
                pb.update('Copying inventory', 0, 1)
 
789
                self.target.inventories.insert_record_stream(
 
790
                    self.source.inventories.get_record_stream(
 
791
                        self.source.inventories.keys(), 'topological', False))
 
792
                self.target.signatures.insert_record_stream(
 
793
                    self.source.signatures.get_record_stream(
 
794
                        self.source.signatures.keys(),
 
795
                        'unordered', True))
 
796
                self.target.revisions.insert_record_stream(
 
797
                    self.source.revisions.get_record_stream(
 
798
                        self.source.revisions.keys(),
 
799
                        'topological', True))
 
800
            finally:
 
801
                pb.finished()
 
802
        else:
 
803
            self.target.fetch(self.source, revision_id=revision_id)
 
804
 
 
805
    @needs_read_lock
 
806
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
807
        """See InterRepository.missing_revision_ids()."""
 
808
        # we want all revisions to satisfy revision_id in source.
 
809
        # but we don't want to stat every file here and there.
 
810
        # we want then, all revisions other needs to satisfy revision_id
 
811
        # checked, but not those that we have locally.
 
812
        # so the first thing is to get a subset of the revisions to
 
813
        # satisfy revision_id in source, and then eliminate those that
 
814
        # we do already have.
 
815
        # this is slow on high latency connection to self, but as this
 
816
        # disk format scales terribly for push anyway due to rewriting
 
817
        # inventory.weave, this is considered acceptable.
 
818
        # - RBC 20060209
 
819
        if revision_id is not None:
 
820
            source_ids = self.source.get_ancestry(revision_id)
 
821
            if source_ids[0] is not None:
 
822
                raise AssertionError()
 
823
            source_ids.pop(0)
 
824
        else:
 
825
            source_ids = self.source._all_possible_ids()
 
826
        source_ids_set = set(source_ids)
 
827
        # source_ids is the worst possible case we may need to pull.
 
828
        # now we want to filter source_ids against what we actually
 
829
        # have in target, but don't try to check for existence where we know
 
830
        # we do not have a revision as that would be pointless.
 
831
        target_ids = set(self.target._all_possible_ids())
 
832
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
833
        actually_present_revisions = set(
 
834
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
835
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
836
        if revision_id is not None:
 
837
            # we used get_ancestry to determine source_ids then we are assured all
 
838
            # revisions referenced are present as they are installed in topological order.
 
839
            # and the tip revision was validated by get_ancestry.
 
840
            result_set = required_revisions
 
841
        else:
 
842
            # if we just grabbed the possibly available ids, then
 
843
            # we only have an estimate of whats available and need to validate
 
844
            # that against the revision records.
 
845
            result_set = set(
 
846
                self.source._eliminate_revisions_not_present(required_revisions))
 
847
        return self.source.revision_ids_to_search_result(result_set)
 
848
 
 
849
 
737
850
_legacy_formats = [RepositoryFormat4(),
738
851
                   RepositoryFormat5(),
739
852
                   RepositoryFormat6()]
 
853
 
 
854
 
 
855
InterRepository.register_optimiser(InterWeaveRepo)