/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 bzrlib/repofmt/weaverepo.py

Merge fetch-spec-everything-not-in-other.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repofmt/weaverepo.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007-2011 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
20
20
ghosts.
21
21
"""
22
22
 
 
23
import gzip
23
24
import os
24
25
from cStringIO import StringIO
25
26
import urllib
29
30
from bzrlib import (
30
31
    xml5,
31
32
    graph as _mod_graph,
 
33
    ui,
32
34
    )
33
35
""")
34
36
from bzrlib import (
38
40
    lockable_files,
39
41
    lockdir,
40
42
    osutils,
41
 
    revision as _mod_revision,
 
43
    symbol_versioning,
42
44
    trace,
 
45
    tuned_gzip,
43
46
    urlutils,
44
47
    versionedfile,
45
48
    weave,
48
51
from bzrlib.decorators import needs_read_lock, needs_write_lock
49
52
from bzrlib.repository import (
50
53
    CommitBuilder,
 
54
    InterRepository,
 
55
    InterSameDataRepository,
51
56
    MetaDirVersionedFileRepository,
52
57
    MetaDirRepositoryFormat,
53
58
    Repository,
54
59
    RepositoryFormat,
55
60
    )
56
61
from bzrlib.store.text import TextStore
57
 
from bzrlib.tuned_gzip import GzipFile, bytes_to_gzip
58
62
from bzrlib.versionedfile import (
59
63
    AbsentContentFactory,
60
64
    FulltextContentFactory,
587
591
            raise ValueError('bad idea to put / in %r' % (key,))
588
592
        text = ''.join(lines)
589
593
        if self._compressed:
590
 
            text = bytes_to_gzip(text)
 
594
            text = tuned_gzip.bytes_to_gzip(text)
591
595
        path = self._map(key)
592
596
        self._transport.put_bytes_non_atomic(path, text, create_parent_dir=True)
593
597
 
635
639
            else:
636
640
                return None
637
641
        if compressed:
638
 
            text = GzipFile(mode='rb', fileobj=StringIO(text)).read()
 
642
            text = gzip.GzipFile(mode='rb', fileobj=StringIO(text)).read()
639
643
        return text
640
644
 
641
645
    def _map(self, key):
738
742
        paths = list(relpaths)
739
743
        return set([self._mapper.unmap(path) for path in paths])
740
744
 
 
745
 
 
746
class InterWeaveRepo(InterSameDataRepository):
 
747
    """Optimised code paths between Weave based repositories.
 
748
    """
 
749
 
 
750
    @classmethod
 
751
    def _get_repo_format_to_test(self):
 
752
        return RepositoryFormat7()
 
753
 
 
754
    @staticmethod
 
755
    def is_compatible(source, target):
 
756
        """Be compatible with known Weave formats.
 
757
 
 
758
        We don't test for the stores being of specific types because that
 
759
        could lead to confusing results, and there is no need to be
 
760
        overly general.
 
761
        """
 
762
        try:
 
763
            return (isinstance(source._format, (RepositoryFormat5,
 
764
                                                RepositoryFormat6,
 
765
                                                RepositoryFormat7)) and
 
766
                    isinstance(target._format, (RepositoryFormat5,
 
767
                                                RepositoryFormat6,
 
768
                                                RepositoryFormat7)))
 
769
        except AttributeError:
 
770
            return False
 
771
 
 
772
    @needs_write_lock
 
773
    def copy_content(self, revision_id=None):
 
774
        """See InterRepository.copy_content()."""
 
775
        # weave specific optimised path:
 
776
        try:
 
777
            self.target.set_make_working_trees(self.source.make_working_trees())
 
778
        except (errors.RepositoryUpgradeRequired, NotImplemented):
 
779
            pass
 
780
        # FIXME do not peek!
 
781
        if self.source._transport.listable():
 
782
            pb = ui.ui_factory.nested_progress_bar()
 
783
            try:
 
784
                self.target.texts.insert_record_stream(
 
785
                    self.source.texts.get_record_stream(
 
786
                        self.source.texts.keys(), 'topological', False))
 
787
                pb.update('Copying inventory', 0, 1)
 
788
                self.target.inventories.insert_record_stream(
 
789
                    self.source.inventories.get_record_stream(
 
790
                        self.source.inventories.keys(), 'topological', False))
 
791
                self.target.signatures.insert_record_stream(
 
792
                    self.source.signatures.get_record_stream(
 
793
                        self.source.signatures.keys(),
 
794
                        'unordered', True))
 
795
                self.target.revisions.insert_record_stream(
 
796
                    self.source.revisions.get_record_stream(
 
797
                        self.source.revisions.keys(),
 
798
                        'topological', True))
 
799
            finally:
 
800
                pb.finished()
 
801
        else:
 
802
            self.target.fetch(self.source, revision_id=revision_id)
 
803
 
 
804
    @needs_read_lock
 
805
    def search_missing_revision_ids(self,
 
806
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
807
            find_ghosts=True, revision_ids=None, if_present_ids=None):
 
808
        """See InterRepository.search_missing_revision_ids()."""
 
809
        # we want all revisions to satisfy revision_id in source.
 
810
        # but we don't want to stat every file here and there.
 
811
        # we want then, all revisions other needs to satisfy revision_id
 
812
        # checked, but not those that we have locally.
 
813
        # so the first thing is to get a subset of the revisions to
 
814
        # satisfy revision_id in source, and then eliminate those that
 
815
        # we do already have.
 
816
        # this is slow on high latency connection to self, but as this
 
817
        # disk format scales terribly for push anyway due to rewriting
 
818
        # inventory.weave, this is considered acceptable.
 
819
        # - RBC 20060209
 
820
        if symbol_versioning.deprecated_passed(revision_id):
 
821
            symbol_versioning.warn(
 
822
                'search_missing_revision_ids(revision_id=...) was '
 
823
                'deprecated in 2.3.  Use revision_ids=[...] instead.',
 
824
                DeprecationWarning, stacklevel=2)
 
825
            if revision_ids is not None:
 
826
                raise AssertionError(
 
827
                    'revision_ids is mutually exclusive with revision_id')
 
828
            if revision_id is not None:
 
829
                revision_ids = [revision_id]
 
830
        del revision_id
 
831
        source_ids_set = self._present_source_revisions_for(
 
832
            revision_ids, if_present_ids)
 
833
        # source_ids is the worst possible case we may need to pull.
 
834
        # now we want to filter source_ids against what we actually
 
835
        # have in target, but don't try to check for existence where we know
 
836
        # we do not have a revision as that would be pointless.
 
837
        target_ids = set(self.target._all_possible_ids())
 
838
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
839
        actually_present_revisions = set(
 
840
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
841
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
842
        if revision_ids is not None:
 
843
            # we used get_ancestry to determine source_ids then we are assured all
 
844
            # revisions referenced are present as they are installed in topological order.
 
845
            # and the tip revision was validated by get_ancestry.
 
846
            result_set = required_revisions
 
847
        else:
 
848
            # if we just grabbed the possibly available ids, then
 
849
            # we only have an estimate of whats available and need to validate
 
850
            # that against the revision records.
 
851
            result_set = set(
 
852
                self.source._eliminate_revisions_not_present(required_revisions))
 
853
        return self.source.revision_ids_to_search_result(result_set)
 
854
 
 
855
 
741
856
_legacy_formats = [RepositoryFormat4(),
742
857
                   RepositoryFormat5(),
743
858
                   RepositoryFormat6()]
 
859
 
 
860
 
 
861
InterRepository.register_optimiser(InterWeaveRepo)