1
# Copyright (C) 2006-2010 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)
40
return '%s(%r)' % (self.__class__.__name__, self._medium)
42
def _send_request(self, protocol_version, method, args, body=None,
43
readv_body=None, body_stream=None):
44
encoder, response_handler = self._construct_protocol(
46
encoder.set_headers(self._headers)
48
if readv_body is not None:
50
"body and readv_body are mutually exclusive.")
51
if body_stream is not None:
53
"body and body_stream are mutually exclusive.")
54
encoder.call_with_body_bytes((method, ) + args, body)
55
elif readv_body is not None:
56
if body_stream is not None:
58
"readv_body and body_stream are mutually exclusive.")
59
encoder.call_with_body_readv_array((method, ) + args, readv_body)
60
elif body_stream is not None:
61
encoder.call_with_body_stream((method, ) + args, body_stream)
63
encoder.call(method, *args)
64
return response_handler
66
def _run_call_hooks(self, method, args, body, readv_body):
67
if not _SmartClient.hooks['call']:
69
params = CallHookParams(method, args, body, readv_body, self._medium)
70
for hook in _SmartClient.hooks['call']:
73
def _call_and_read_response(self, method, args, body=None, readv_body=None,
74
body_stream=None, expect_response_body=True):
75
self._run_call_hooks(method, args, body, readv_body)
76
if self._medium._protocol_version is not None:
77
response_handler = self._send_request(
78
self._medium._protocol_version, method, args, body=body,
79
readv_body=readv_body, body_stream=body_stream)
80
return (response_handler.read_response_tuple(
81
expect_body=expect_response_body),
84
for protocol_version in [3, 2]:
85
if protocol_version == 2:
86
# If v3 doesn't work, the remote side is older than 1.6.
87
self._medium._remember_remote_is_before((1, 6))
88
response_handler = self._send_request(
89
protocol_version, method, args, body=body,
90
readv_body=readv_body, body_stream=body_stream)
92
response_tuple = response_handler.read_response_tuple(
93
expect_body=expect_response_body)
94
except errors.UnexpectedProtocolVersionMarker, err:
95
# TODO: We could recover from this without disconnecting if
96
# we recognise the protocol version.
98
'Server does not understand Bazaar network protocol %d,'
99
' reconnecting. (Upgrade the server to avoid this.)'
100
% (protocol_version,))
101
self._medium.disconnect()
103
except errors.ErrorFromSmartServer:
104
# If we received an error reply from the server, then it
105
# must be ok with this protocol version.
106
self._medium._protocol_version = protocol_version
109
self._medium._protocol_version = protocol_version
110
return response_tuple, response_handler
111
raise errors.SmartProtocolError(
112
'Server is not a Bazaar server: ' + str(err))
114
def _construct_protocol(self, version):
115
request = self._medium.get_request()
117
request_encoder = protocol.ProtocolThreeRequester(request)
118
response_handler = message.ConventionalResponseHandler()
119
response_proto = protocol.ProtocolThreeDecoder(
120
response_handler, expect_version_marker=True)
121
response_handler.setProtoAndMediumRequest(response_proto, request)
123
request_encoder = protocol.SmartClientRequestProtocolTwo(request)
124
response_handler = request_encoder
126
request_encoder = protocol.SmartClientRequestProtocolOne(request)
127
response_handler = request_encoder
128
return request_encoder, response_handler
130
def call(self, method, *args):
131
"""Call a method on the remote server."""
132
result, protocol = self.call_expecting_body(method, *args)
133
protocol.cancel_read_body()
136
def call_expecting_body(self, method, *args):
137
"""Call a method and return the result and the protocol object.
139
The body can be read like so::
141
result, smart_protocol = smart_client.call_expecting_body(...)
142
body = smart_protocol.read_body_bytes()
144
return self._call_and_read_response(
145
method, args, expect_response_body=True)
147
def call_with_body_bytes(self, method, args, body):
148
"""Call a method on the remote server with body bytes."""
149
if type(method) is not str:
150
raise TypeError('method must be a byte string, not %r' % (method,))
152
if type(arg) is not str:
153
raise TypeError('args must be byte strings, not %r' % (args,))
154
if type(body) is not str:
155
raise TypeError('body must be byte string, not %r' % (body,))
156
response, response_handler = self._call_and_read_response(
157
method, args, body=body, expect_response_body=False)
160
def call_with_body_bytes_expecting_body(self, method, args, body):
161
"""Call a method on the remote server with body bytes."""
162
if type(method) is not str:
163
raise TypeError('method must be a byte string, not %r' % (method,))
165
if type(arg) is not str:
166
raise TypeError('args must be byte strings, not %r' % (args,))
167
if type(body) is not str:
168
raise TypeError('body must be byte string, not %r' % (body,))
169
response, response_handler = self._call_and_read_response(
170
method, args, body=body, expect_response_body=True)
171
return (response, response_handler)
173
def call_with_body_readv_array(self, args, body):
174
response, response_handler = self._call_and_read_response(
175
args[0], args[1:], readv_body=body, expect_response_body=True)
176
return (response, response_handler)
178
def call_with_body_stream(self, args, stream):
179
response, response_handler = self._call_and_read_response(
180
args[0], args[1:], body_stream=stream,
181
expect_response_body=False)
182
return (response, response_handler)
184
def remote_path_from_transport(self, transport):
185
"""Convert transport into a path suitable for using in a request.
187
Note that the resulting remote path doesn't encode the host name or
188
anything but path, so it is only safe to use it in requests sent over
189
the medium from the matching transport.
191
return self._medium.remote_path_from_transport(transport)
194
class SmartClientHooks(hooks.Hooks):
197
hooks.Hooks.__init__(self)
198
self.create_hook(hooks.HookPoint('call',
199
"Called when the smart client is submitting a request to the "
200
"smart server. Called with a bzrlib.smart.client.CallHookParams "
201
"object. Streaming request bodies, and responses, are not "
202
"accessible.", None, None))
205
_SmartClient.hooks = SmartClientHooks()
208
class CallHookParams(object):
210
def __init__(self, method, args, body, readv_body, medium):
214
self.readv_body = readv_body
218
attrs = dict((k, v) for (k, v) in self.__dict__.iteritems()
220
return '<%s %r>' % (self.__class__.__name__, attrs)
222
def __eq__(self, other):
223
if type(other) is not type(self):
224
return NotImplemented
225
return self.__dict__ == other.__dict__
227
def __ne__(self, other):
228
return not self == other
added
removed
bzrlib/smart/client.py
