1
# Copyright (C) 2006-2008 Canonical Ltd
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.
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.
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
18
from bzrlib.smart import message, protocol
19
from bzrlib.trace import warning
26
class _SmartClient(object):
28
def __init__(self, medium, headers=None):
31
:param medium: a SmartClientMedium
35
self._headers = {'Software version': bzrlib.__version__}
37
self._headers = dict(headers)
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(
43
encoder.set_headers(self._headers)
45
if readv_body is not None:
47
"body and readv_body are mutually exclusive.")
48
if body_stream is not None:
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:
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)
60
encoder.call(method, *args)
61
return response_handler
63
def _run_call_hooks(self, method, args, body, readv_body):
64
if not _SmartClient.hooks['call']:
66
params = CallHookParams(method, args, body, readv_body, self._medium)
67
for hook in _SmartClient.hooks['call']:
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),
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)
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.
95
'Server does not understand Bazaar network protocol %d,'
96
' reconnecting. (Upgrade the server to avoid this.)'
97
% (protocol_version,))
98
self._medium.disconnect()
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
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))
111
def _construct_protocol(self, version):
112
request = self._medium.get_request()
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)
120
request_encoder = protocol.SmartClientRequestProtocolTwo(request)
121
response_handler = request_encoder
123
request_encoder = protocol.SmartClientRequestProtocolOne(request)
124
response_handler = request_encoder
125
return request_encoder, response_handler
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()
133
def call_expecting_body(self, method, *args):
134
"""Call a method and return the result and the protocol object.
136
The body can be read like so::
138
result, smart_protocol = smart_client.call_expecting_body(...)
139
body = smart_protocol.read_body_bytes()
141
return self._call_and_read_response(
142
method, args, expect_response_body=True)
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,))
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)
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,))
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)
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)
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)
181
def remote_path_from_transport(self, transport):
182
"""Convert transport into a path suitable for using in a request.
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.
188
return self._medium.remote_path_from_transport(transport)
191
class SmartClientHooks(hooks.Hooks):
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))
202
_SmartClient.hooks = SmartClientHooks()
205
class CallHookParams(object):
207
def __init__(self, method, args, body, readv_body, medium):
211
self.readv_body = readv_body
215
attrs = dict((k, v) for (k, v) in self.__dict__.iteritems()
217
return '<%s %r>' % (self.__class__.__name__, attrs)
219
def __eq__(self, other):
220
if type(other) is not type(self):
221
return NotImplemented
222
return self.__dict__ == other.__dict__
224
def __ne__(self, other):
225
return not self == other
added
removed
bzrlib/smart/client.py
