← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/client.py

  • Committer: Joe Julian
  • Date: 2010-01-10 02:25:31 UTC
  • mto: (4634.119.7 2.0)
  • mto: This revision was merged to the branch mainline in revision 4959.
  • Revision ID: joe@julianfamily.org-20100110022531-wqk61rsagz8xsiga
https://launchpad.net/bugs/175839
Added MANIFEST.in to allow bdist_rpm to have all the required include files and tools. bdist_rpm will still fail to build correctly on some distributions due to a disttools bug http://bugs.python.org/issue644744

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/client.py
 
1
# Copyright (C) 2006-2008 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
import bzrlib
 
18
from bzrlib.smart import message, protocol
 
19
from bzrlib.trace import warning
 
20
from bzrlib import (
 
21
    errors,
 
22
    hooks,
 
23
    )
 
24
 
 
25
 
 
26
class _SmartClient(object):
 
27
 
 
28
    def __init__(self, medium, headers=None):
 
29
        """Constructor.
 
30
 
 
31
        :param medium: a SmartClientMedium
 
32
        """
 
33
        self._medium = medium
 
34
        if headers is None:
 
35
            self._headers = {'Software version': bzrlib.__version__}
 
36
        else:
 
37
            self._headers = dict(headers)
 
38
 
 
39
    def _send_request(self, protocol_version, method, args, body=None,
 
40
                      readv_body=None, body_stream=None):
 
41
        encoder, response_handler = self._construct_protocol(
 
42
            protocol_version)
 
43
        encoder.set_headers(self._headers)
 
44
        if body is not None:
 
45
            if readv_body is not None:
 
46
                raise AssertionError(
 
47
                    "body and readv_body are mutually exclusive.")
 
48
            if body_stream is not None:
 
49
                raise AssertionError(
 
50
                    "body and body_stream are mutually exclusive.")
 
51
            encoder.call_with_body_bytes((method, ) + args, body)
 
52
        elif readv_body is not None:
 
53
            if body_stream is not None:
 
54
                raise AssertionError(
 
55
                    "readv_body and body_stream are mutually exclusive.")
 
56
            encoder.call_with_body_readv_array((method, ) + args, readv_body)
 
57
        elif body_stream is not None:
 
58
            encoder.call_with_body_stream((method, ) + args, body_stream)
 
59
        else:
 
60
            encoder.call(method, *args)
 
61
        return response_handler
 
62
 
 
63
    def _run_call_hooks(self, method, args, body, readv_body):
 
64
        if not _SmartClient.hooks['call']:
 
65
            return
 
66
        params = CallHookParams(method, args, body, readv_body, self._medium)
 
67
        for hook in _SmartClient.hooks['call']:
 
68
            hook(params)
 
69
 
 
70
    def _call_and_read_response(self, method, args, body=None, readv_body=None,
 
71
            body_stream=None, expect_response_body=True):
 
72
        self._run_call_hooks(method, args, body, readv_body)
 
73
        if self._medium._protocol_version is not None:
 
74
            response_handler = self._send_request(
 
75
                self._medium._protocol_version, method, args, body=body,
 
76
                readv_body=readv_body, body_stream=body_stream)
 
77
            return (response_handler.read_response_tuple(
 
78
                        expect_body=expect_response_body),
 
79
                    response_handler)
 
80
        else:
 
81
            for protocol_version in [3, 2]:
 
82
                if protocol_version == 2:
 
83
                    # If v3 doesn't work, the remote side is older than 1.6.
 
84
                    self._medium._remember_remote_is_before((1, 6))
 
85
                response_handler = self._send_request(
 
86
                    protocol_version, method, args, body=body,
 
87
                    readv_body=readv_body, body_stream=body_stream)
 
88
                try:
 
89
                    response_tuple = response_handler.read_response_tuple(
 
90
                        expect_body=expect_response_body)
 
91
                except errors.UnexpectedProtocolVersionMarker, err:
 
92
                    # TODO: We could recover from this without disconnecting if
 
93
                    # we recognise the protocol version.
 
94
                    warning(
 
95
                        'Server does not understand Bazaar network protocol %d,'
 
96
                        ' reconnecting.  (Upgrade the server to avoid this.)'
 
97
                        % (protocol_version,))
 
98
                    self._medium.disconnect()
 
99
                    continue
 
100
                except errors.ErrorFromSmartServer:
 
101
                    # If we received an error reply from the server, then it
 
102
                    # must be ok with this protocol version.
 
103
                    self._medium._protocol_version = protocol_version
 
104
                    raise
 
105
                else:
 
106
                    self._medium._protocol_version = protocol_version
 
107
                    return response_tuple, response_handler
 
108
            raise errors.SmartProtocolError(
 
109
                'Server is not a Bazaar server: ' + str(err))
 
110
 
 
111
    def _construct_protocol(self, version):
 
112
        request = self._medium.get_request()
 
113
        if version == 3:
 
114
            request_encoder = protocol.ProtocolThreeRequester(request)
 
115
            response_handler = message.ConventionalResponseHandler()
 
116
            response_proto = protocol.ProtocolThreeDecoder(
 
117
                response_handler, expect_version_marker=True)
 
118
            response_handler.setProtoAndMediumRequest(response_proto, request)
 
119
        elif version == 2:
 
120
            request_encoder = protocol.SmartClientRequestProtocolTwo(request)
 
121
            response_handler = request_encoder
 
122
        else:
 
123
            request_encoder = protocol.SmartClientRequestProtocolOne(request)
 
124
            response_handler = request_encoder
 
125
        return request_encoder, response_handler
 
126
 
 
127
    def call(self, method, *args):
 
128
        """Call a method on the remote server."""
 
129
        result, protocol = self.call_expecting_body(method, *args)
 
130
        protocol.cancel_read_body()
 
131
        return result
 
132
 
 
133
    def call_expecting_body(self, method, *args):
 
134
        """Call a method and return the result and the protocol object.
 
135
 
 
136
        The body can be read like so::
 
137
 
 
138
            result, smart_protocol = smart_client.call_expecting_body(...)
 
139
            body = smart_protocol.read_body_bytes()
 
140
        """
 
141
        return self._call_and_read_response(
 
142
            method, args, expect_response_body=True)
 
143
 
 
144
    def call_with_body_bytes(self, method, args, body):
 
145
        """Call a method on the remote server with body bytes."""
 
146
        if type(method) is not str:
 
147
            raise TypeError('method must be a byte string, not %r' % (method,))
 
148
        for arg in args:
 
149
            if type(arg) is not str:
 
150
                raise TypeError('args must be byte strings, not %r' % (args,))
 
151
        if type(body) is not str:
 
152
            raise TypeError('body must be byte string, not %r' % (body,))
 
153
        response, response_handler = self._call_and_read_response(
 
154
            method, args, body=body, expect_response_body=False)
 
155
        return response
 
156
 
 
157
    def call_with_body_bytes_expecting_body(self, method, args, body):
 
158
        """Call a method on the remote server with body bytes."""
 
159
        if type(method) is not str:
 
160
            raise TypeError('method must be a byte string, not %r' % (method,))
 
161
        for arg in args:
 
162
            if type(arg) is not str:
 
163
                raise TypeError('args must be byte strings, not %r' % (args,))
 
164
        if type(body) is not str:
 
165
            raise TypeError('body must be byte string, not %r' % (body,))
 
166
        response, response_handler = self._call_and_read_response(
 
167
            method, args, body=body, expect_response_body=True)
 
168
        return (response, response_handler)
 
169
 
 
170
    def call_with_body_readv_array(self, args, body):
 
171
        response, response_handler = self._call_and_read_response(
 
172
                args[0], args[1:], readv_body=body, expect_response_body=True)
 
173
        return (response, response_handler)
 
174
 
 
175
    def call_with_body_stream(self, args, stream):
 
176
        response, response_handler = self._call_and_read_response(
 
177
                args[0], args[1:], body_stream=stream,
 
178
                expect_response_body=False)
 
179
        return (response, response_handler)
 
180
 
 
181
    def remote_path_from_transport(self, transport):
 
182
        """Convert transport into a path suitable for using in a request.
 
183
 
 
184
        Note that the resulting remote path doesn't encode the host name or
 
185
        anything but path, so it is only safe to use it in requests sent over
 
186
        the medium from the matching transport.
 
187
        """
 
188
        return self._medium.remote_path_from_transport(transport)
 
189
 
 
190
 
 
191
class SmartClientHooks(hooks.Hooks):
 
192
 
 
193
    def __init__(self):
 
194
        hooks.Hooks.__init__(self)
 
195
        self.create_hook(hooks.HookPoint('call',
 
196
            "Called when the smart client is submitting a request to the "
 
197
            "smart server. Called with a bzrlib.smart.client.CallHookParams "
 
198
            "object. Streaming request bodies, and responses, are not "
 
199
            "accessible.", None, None))
 
200
 
 
201
 
 
202
_SmartClient.hooks = SmartClientHooks()
 
203
 
 
204
 
 
205
class CallHookParams(object):
 
206
 
 
207
    def __init__(self, method, args, body, readv_body, medium):
 
208
        self.method = method
 
209
        self.args = args
 
210
        self.body = body
 
211
        self.readv_body = readv_body
 
212
        self.medium = medium
 
213
 
 
214
    def __repr__(self):
 
215
        attrs = dict((k, v) for (k, v) in self.__dict__.iteritems()
 
216
                     if v is not None)
 
217
        return '<%s %r>' % (self.__class__.__name__, attrs)
 
218
 
 
219
    def __eq__(self, other):
 
220
        if type(other) is not type(self):
 
221
            return NotImplemented
 
222
        return self.__dict__ == other.__dict__
 
223
 
 
224
    def __ne__(self, other):
 
225
        return not self == other