← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

First cut at pluralised VersionedFiles. Some rather massive API incompatabilities, primarily because of the difficulty of coherence among competing stores.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
709
709
        self._ensure_real()
710
710
        return self._real_repository.get_revision(revision_id)
711
711
 
712
 
    @property
713
 
    def weave_store(self):
714
 
        self._ensure_real()
715
 
        return self._real_repository.weave_store
716
 
 
717
712
    def get_transaction(self):
718
713
        self._ensure_real()
719
714
        return self._real_repository.get_transaction()
768
763
        self._ensure_real()
769
764
        self._real_repository.create_bundle(target, base, fileobj, format)
770
765
 
771
 
    @property
772
 
    def control_weaves(self):
773
 
        self._ensure_real()
774
 
        return self._real_repository.control_weaves
775
 
 
776
766
    @needs_read_lock
777
767
    def get_ancestry(self, revision_id, topo_sorted=True):
778
768
        self._ensure_real()
779
769
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
780
770
 
781
 
    @needs_read_lock
782
 
    def get_inventory_weave(self):
 
771
    @property
 
772
    def inventories(self):
783
773
        self._ensure_real()
784
 
        return self._real_repository.get_inventory_weave()
 
774
        return self._real_repository.inventories
785
775
 
786
776
    def fileids_altered_by_revision_ids(self, revision_ids):
787
777
        self._ensure_real()
1011
1001
        # TODO: Suggestion from john: using external tar is much faster than
1012
1002
        # python's tarfile library, but it may not work on windows.
1013
1003
 
 
1004
    @property
 
1005
    def inventories(self):
 
1006
        """Decorate the real repository for now.
 
1007
 
 
1008
        In the long term a full blown network facility is needed to
 
1009
        avoid creating a real repository object locally.
 
1010
        """
 
1011
        self._ensure_real()
 
1012
        return self._real_repository.inventories
 
1013
 
1014
1014
    @needs_write_lock
1015
1015
    def pack(self):
1016
1016
        """Compress the data within the repository.
1020
1020
        self._ensure_real()
1021
1021
        return self._real_repository.pack()
1022
1022
 
 
1023
    @property
 
1024
    def revisions(self):
 
1025
        """Decorate the real repository for now.
 
1026
 
 
1027
        In the short term this should become a real object to intercept graph
 
1028
        lookups.
 
1029
 
 
1030
        In the long term a full blown network facility is needed.
 
1031
        """
 
1032
        self._ensure_real()
 
1033
        return self._real_repository.revisions
 
1034
 
1023
1035
    def set_make_working_trees(self, new_value):
1024
1036
        self._ensure_real()
1025
1037
        self._real_repository.set_make_working_trees(new_value)
1026
1038
 
 
1039
    @property
 
1040
    def signatures(self):
 
1041
        """Decorate the real repository for now.
 
1042
 
 
1043
        In the long term a full blown network facility is needed to avoid
 
1044
        creating a real repository object locally.
 
1045
        """
 
1046
        self._ensure_real()
 
1047
        return self._real_repository.signatures
 
1048
 
1027
1049
    @needs_write_lock
1028
1050
    def sign_revision(self, revision_id, gpg_strategy):
1029
1051
        self._ensure_real()
1030
1052
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
1031
1053
 
 
1054
    @property
 
1055
    def texts(self):
 
1056
        """Decorate the real repository for now.
 
1057
 
 
1058
        In the long term a full blown network facility is needed to avoid
 
1059
        creating a real repository object locally.
 
1060
        """
 
1061
        self._ensure_real()
 
1062
        return self._real_repository.texts
 
1063
 
1032
1064
    @needs_read_lock
1033
1065
    def get_revisions(self, revision_ids):
1034
1066
        self._ensure_real()
1060
1092
        self._ensure_real()
1061
1093
        return self._real_repository.has_signature_for_revision_id(revision_id)
1062
1094
 
1063
 
    def get_data_stream_for_search(self, search):
1064
 
        medium = self._client._medium
1065
 
        if not medium._remote_is_at_least_1_2:
1066
 
            self._ensure_real()
1067
 
            return self._real_repository.get_data_stream_for_search(search)
1068
 
        REQUEST_NAME = 'Repository.stream_revisions_chunked'
1069
 
        path = self.bzrdir._path_for_remote_call(self._client)
1070
 
        body = self._serialise_search_recipe(search.get_recipe())
1071
 
        try:
1072
 
            result = self._client.call_with_body_bytes_expecting_body(
1073
 
                REQUEST_NAME, (path,), body)
1074
 
            response, protocol = result
1075
 
        except errors.UnknownSmartMethod:
1076
 
            # Server does not support this method, so fall back to VFS.
1077
 
            # Worse, we have to force a disconnection, because the server now
1078
 
            # doesn't realise it has a body on the wire to consume, so the
1079
 
            # only way to recover is to abandon the connection.
1080
 
            warning(
1081
 
                'Server is too old for streaming pull, reconnecting.  '
1082
 
                '(Upgrade the server to Bazaar 1.2 to avoid this)')
1083
 
            medium.disconnect()
1084
 
            # To avoid having to disconnect repeatedly, we keep track of the
1085
 
            # fact the server doesn't understand this remote method.
1086
 
            medium._remote_is_at_least_1_2 = False
1087
 
            self._ensure_real()
1088
 
            return self._real_repository.get_data_stream_for_search(search)
1089
 
 
1090
 
        if response == ('ok',):
1091
 
            return self._deserialise_stream(protocol)
1092
 
        if response == ('NoSuchRevision', ):
1093
 
            # We cannot easily identify the revision that is missing in this
1094
 
            # situation without doing much more network IO. For now, bail.
1095
 
            raise NoSuchRevision(self, "unknown")
1096
 
        else:
1097
 
            raise errors.UnexpectedSmartServerResponse(response)
1098
 
 
1099
 
    def _deserialise_stream(self, protocol):
1100
 
        stream = protocol.read_streamed_body()
1101
 
        container_parser = ContainerPushParser()
1102
 
        for bytes in stream:
1103
 
            container_parser.accept_bytes(bytes)
1104
 
            records = container_parser.read_pending_records()
1105
 
            for record_names, record_bytes in records:
1106
 
                if len(record_names) != 1:
1107
 
                    # These records should have only one name, and that name
1108
 
                    # should be a one-element tuple.
1109
 
                    raise errors.SmartProtocolError(
1110
 
                        'Repository data stream had invalid record name %r'
1111
 
                        % (record_names,))
1112
 
                name_tuple = record_names[0]
1113
 
                yield name_tuple, record_bytes
1114
 
 
1115
 
    def insert_data_stream(self, stream):
1116
 
        self._ensure_real()
1117
 
        self._real_repository.insert_data_stream(stream)
1118
 
 
1119
1095
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1120
1096
        self._ensure_real()
1121
1097
        return self._real_repository.item_keys_introduced_by(revision_ids,