/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/smart/client.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/client.py
1
 
# Copyright (C) 2006-2008 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import bzrlib
18
18
from bzrlib.smart import message, protocol
36
36
        else:
37
37
            self._headers = dict(headers)
38
38
 
 
39
    def __repr__(self):
 
40
        return '%s(%r)' % (self.__class__.__name__, self._medium)
 
41
 
39
42
    def _send_request(self, protocol_version, method, args, body=None,
40
 
                      readv_body=None):
 
43
                      readv_body=None, body_stream=None):
41
44
        encoder, response_handler = self._construct_protocol(
42
45
            protocol_version)
43
46
        encoder.set_headers(self._headers)
45
48
            if readv_body is not None:
46
49
                raise AssertionError(
47
50
                    "body and readv_body are mutually exclusive.")
 
51
            if body_stream is not None:
 
52
                raise AssertionError(
 
53
                    "body and body_stream are mutually exclusive.")
48
54
            encoder.call_with_body_bytes((method, ) + args, body)
49
55
        elif readv_body is not None:
50
 
            encoder.call_with_body_readv_array((method, ) + args,
51
 
                    readv_body)
 
56
            if body_stream is not None:
 
57
                raise AssertionError(
 
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)
52
62
        else:
53
63
            encoder.call(method, *args)
54
64
        return response_handler
59
69
        params = CallHookParams(method, args, body, readv_body, self._medium)
60
70
        for hook in _SmartClient.hooks['call']:
61
71
            hook(params)
62
 
            
 
72
 
63
73
    def _call_and_read_response(self, method, args, body=None, readv_body=None,
64
 
            expect_response_body=True):
 
74
            body_stream=None, expect_response_body=True):
65
75
        self._run_call_hooks(method, args, body, readv_body)
66
76
        if self._medium._protocol_version is not None:
67
77
            response_handler = self._send_request(
68
78
                self._medium._protocol_version, method, args, body=body,
69
 
                readv_body=readv_body)
 
79
                readv_body=readv_body, body_stream=body_stream)
70
80
            return (response_handler.read_response_tuple(
71
81
                        expect_body=expect_response_body),
72
82
                    response_handler)
77
87
                    self._medium._remember_remote_is_before((1, 6))
78
88
                response_handler = self._send_request(
79
89
                    protocol_version, method, args, body=body,
80
 
                    readv_body=readv_body)
 
90
                    readv_body=readv_body, body_stream=body_stream)
81
91
                try:
82
92
                    response_tuple = response_handler.read_response_tuple(
83
93
                        expect_body=expect_response_body)
125
135
 
126
136
    def call_expecting_body(self, method, *args):
127
137
        """Call a method and return the result and the protocol object.
128
 
        
 
138
 
129
139
        The body can be read like so::
130
140
 
131
141
            result, smart_protocol = smart_client.call_expecting_body(...)
165
175
                args[0], args[1:], readv_body=body, expect_response_body=True)
166
176
        return (response, response_handler)
167
177
 
 
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)
 
183
 
168
184
    def remote_path_from_transport(self, transport):
169
185
        """Convert transport into a path suitable for using in a request.
170
 
        
 
186
 
171
187
        Note that the resulting remote path doesn't encode the host name or
172
188
        anything but path, so it is only safe to use it in requests sent over
173
189
        the medium from the matching transport.
179
195
 
180
196
    def __init__(self):
181
197
        hooks.Hooks.__init__(self)
182
 
        self['call'] = []
183
 
 
184
 
        
 
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))
 
203
 
 
204
 
185
205
_SmartClient.hooks = SmartClientHooks()
186
206
 
187
207
 
188
208
class CallHookParams(object):
189
 
    
 
209
 
190
210
    def __init__(self, method, args, body, readv_body, medium):
191
211
        self.method = method
192
212
        self.args = args