← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-06-25 10:36:36 UTC
  • mfrom: (3350.6.12 versionedfiles)
  • Revision ID: pqm@pqm.ubuntu.com-20080625103636-6kxh4e1gmyn82f50
(mbp for robertc) VersionedFiles refactoring

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
723
723
        self._ensure_real()
724
724
        return self._real_repository.get_revision(revision_id)
725
725
 
726
 
    @property
727
 
    def weave_store(self):
728
 
        self._ensure_real()
729
 
        return self._real_repository.weave_store
730
 
 
731
726
    def get_transaction(self):
732
727
        self._ensure_real()
733
728
        return self._real_repository.get_transaction()
782
777
        self._ensure_real()
783
778
        self._real_repository.create_bundle(target, base, fileobj, format)
784
779
 
785
 
    @property
786
 
    def control_weaves(self):
787
 
        self._ensure_real()
788
 
        return self._real_repository.control_weaves
789
 
 
790
780
    @needs_read_lock
791
781
    def get_ancestry(self, revision_id, topo_sorted=True):
792
782
        self._ensure_real()
793
783
        return self._real_repository.get_ancestry(revision_id, topo_sorted)
794
784
 
795
 
    @needs_read_lock
796
 
    def get_inventory_weave(self):
797
 
        self._ensure_real()
798
 
        return self._real_repository.get_inventory_weave()
799
 
 
800
785
    def fileids_altered_by_revision_ids(self, revision_ids):
801
786
        self._ensure_real()
802
787
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
1029
1014
        # TODO: Suggestion from john: using external tar is much faster than
1030
1015
        # python's tarfile library, but it may not work on windows.
1031
1016
 
 
1017
    @property
 
1018
    def inventories(self):
 
1019
        """Decorate the real repository for now.
 
1020
 
 
1021
        In the long term a full blown network facility is needed to
 
1022
        avoid creating a real repository object locally.
 
1023
        """
 
1024
        self._ensure_real()
 
1025
        return self._real_repository.inventories
 
1026
 
1032
1027
    @needs_write_lock
1033
1028
    def pack(self):
1034
1029
        """Compress the data within the repository.
1038
1033
        self._ensure_real()
1039
1034
        return self._real_repository.pack()
1040
1035
 
 
1036
    @property
 
1037
    def revisions(self):
 
1038
        """Decorate the real repository for now.
 
1039
 
 
1040
        In the short term this should become a real object to intercept graph
 
1041
        lookups.
 
1042
 
 
1043
        In the long term a full blown network facility is needed.
 
1044
        """
 
1045
        self._ensure_real()
 
1046
        return self._real_repository.revisions
 
1047
 
1041
1048
    def set_make_working_trees(self, new_value):
1042
1049
        self._ensure_real()
1043
1050
        self._real_repository.set_make_working_trees(new_value)
1044
1051
 
 
1052
    @property
 
1053
    def signatures(self):
 
1054
        """Decorate the real repository for now.
 
1055
 
 
1056
        In the long term a full blown network facility is needed to avoid
 
1057
        creating a real repository object locally.
 
1058
        """
 
1059
        self._ensure_real()
 
1060
        return self._real_repository.signatures
 
1061
 
1045
1062
    @needs_write_lock
1046
1063
    def sign_revision(self, revision_id, gpg_strategy):
1047
1064
        self._ensure_real()
1048
1065
        return self._real_repository.sign_revision(revision_id, gpg_strategy)
1049
1066
 
 
1067
    @property
 
1068
    def texts(self):
 
1069
        """Decorate the real repository for now.
 
1070
 
 
1071
        In the long term a full blown network facility is needed to avoid
 
1072
        creating a real repository object locally.
 
1073
        """
 
1074
        self._ensure_real()
 
1075
        return self._real_repository.texts
 
1076
 
1050
1077
    @needs_read_lock
1051
1078
    def get_revisions(self, revision_ids):
1052
1079
        self._ensure_real()
1078
1105
        self._ensure_real()
1079
1106
        return self._real_repository.has_signature_for_revision_id(revision_id)
1080
1107
 
1081
 
    def get_data_stream_for_search(self, search):
1082
 
        medium = self._client._medium
1083
 
        if medium._is_remote_before((1, 2)):
1084
 
            self._ensure_real()
1085
 
            return self._real_repository.get_data_stream_for_search(search)
1086
 
        REQUEST_NAME = 'Repository.stream_revisions_chunked'
1087
 
        path = self.bzrdir._path_for_remote_call(self._client)
1088
 
        body = self._serialise_search_recipe(search.get_recipe())
1089
 
        try:
1090
 
            result = self._client.call_with_body_bytes_expecting_body(
1091
 
                REQUEST_NAME, (path,), body)
1092
 
            response, protocol = result
1093
 
        except errors.UnknownSmartMethod:
1094
 
            # Server does not support this method, so fall back to VFS.
1095
 
            # Worse, we have to force a disconnection, because the server now
1096
 
            # doesn't realise it has a body on the wire to consume, so the
1097
 
            # only way to recover is to abandon the connection.
1098
 
            warning(
1099
 
                'Server is too old for streaming pull, reconnecting.  '
1100
 
                '(Upgrade the server to Bazaar 1.2 to avoid this)')
1101
 
            medium.disconnect()
1102
 
            # To avoid having to disconnect repeatedly, we keep track of the
1103
 
            # fact the server doesn't understand this remote method.
1104
 
            medium._remember_remote_is_before((1, 2))
1105
 
            self._ensure_real()
1106
 
            return self._real_repository.get_data_stream_for_search(search)
1107
 
 
1108
 
        if response == ('ok',):
1109
 
            return self._deserialise_stream(protocol)
1110
 
        if response == ('NoSuchRevision', ):
1111
 
            # We cannot easily identify the revision that is missing in this
1112
 
            # situation without doing much more network IO. For now, bail.
1113
 
            raise NoSuchRevision(self, "unknown")
1114
 
        else:
1115
 
            raise errors.UnexpectedSmartServerResponse(response)
1116
 
 
1117
 
    def _deserialise_stream(self, protocol):
1118
 
        stream = protocol.read_streamed_body()
1119
 
        container_parser = ContainerPushParser()
1120
 
        for bytes in stream:
1121
 
            container_parser.accept_bytes(bytes)
1122
 
            records = container_parser.read_pending_records()
1123
 
            for record_names, record_bytes in records:
1124
 
                if len(record_names) != 1:
1125
 
                    # These records should have only one name, and that name
1126
 
                    # should be a one-element tuple.
1127
 
                    raise errors.SmartProtocolError(
1128
 
                        'Repository data stream had invalid record name %r'
1129
 
                        % (record_names,))
1130
 
                name_tuple = record_names[0]
1131
 
                yield name_tuple, record_bytes
1132
 
 
1133
 
    def insert_data_stream(self, stream):
1134
 
        self._ensure_real()
1135
 
        self._real_repository.insert_data_stream(stream)
1136
 
 
1137
1108
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1138
1109
        self._ensure_real()
1139
1110
        return self._real_repository.item_keys_introduced_by(revision_ids,