/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: Benjamin Rister
  • Date: 2008-05-19 00:16:24 UTC
  • mto: (3453.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3454.
  • Revision ID: bdr@decimus.net-20080519001624-80caaxg8d9niawr7
'Straitjacket' isn't hyphenated

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/client.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2008 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import urllib
16
18
 
17
19
import bzrlib
18
20
from bzrlib.smart import message, protocol
19
21
from bzrlib.trace import warning
20
 
from bzrlib import (
21
 
    errors,
22
 
    hooks,
23
 
    )
 
22
from bzrlib import urlutils, errors
24
23
 
25
24
 
26
25
class _SmartClient(object):
27
26
 
28
 
    def __init__(self, medium, headers=None):
 
27
    def __init__(self, medium, base, headers=None):
29
28
        """Constructor.
30
29
 
31
30
        :param medium: a SmartClientMedium
 
31
        :param base: a URL
32
32
        """
33
33
        self._medium = medium
 
34
        self._base = base
34
35
        if headers is None:
35
36
            self._headers = {'Software version': bzrlib.__version__}
36
37
        else:
37
38
            self._headers = dict(headers)
38
39
 
39
 
    def __repr__(self):
40
 
        return '%s(%r)' % (self.__class__.__name__, self._medium)
41
 
 
42
40
    def _send_request(self, protocol_version, method, args, body=None,
43
 
                      readv_body=None, body_stream=None):
 
41
                      readv_body=None):
44
42
        encoder, response_handler = self._construct_protocol(
45
43
            protocol_version)
46
44
        encoder.set_headers(self._headers)
48
46
            if readv_body is not None:
49
47
                raise AssertionError(
50
48
                    "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.")
54
49
            encoder.call_with_body_bytes((method, ) + args, body)
55
50
        elif readv_body is not None:
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)
 
51
            encoder.call_with_body_readv_array((method, ) + args,
 
52
                    readv_body)
62
53
        else:
63
54
            encoder.call(method, *args)
64
55
        return response_handler
65
56
 
66
 
    def _run_call_hooks(self, method, args, body, readv_body):
67
 
        if not _SmartClient.hooks['call']:
68
 
            return
69
 
        params = CallHookParams(method, args, body, readv_body, self._medium)
70
 
        for hook in _SmartClient.hooks['call']:
71
 
            hook(params)
72
 
 
73
57
    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)
 
58
            expect_response_body=True):
76
59
        if self._medium._protocol_version is not None:
77
60
            response_handler = self._send_request(
78
61
                self._medium._protocol_version, method, args, body=body,
79
 
                readv_body=readv_body, body_stream=body_stream)
 
62
                readv_body=readv_body)
80
63
            return (response_handler.read_response_tuple(
81
64
                        expect_body=expect_response_body),
82
65
                    response_handler)
83
66
        else:
84
67
            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
68
                response_handler = self._send_request(
89
69
                    protocol_version, method, args, body=body,
90
 
                    readv_body=readv_body, body_stream=body_stream)
 
70
                    readv_body=readv_body)
91
71
                try:
92
72
                    response_tuple = response_handler.read_response_tuple(
93
73
                        expect_body=expect_response_body)
100
80
                        % (protocol_version,))
101
81
                    self._medium.disconnect()
102
82
                    continue
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
107
 
                    raise
108
83
                else:
109
84
                    self._medium._protocol_version = protocol_version
110
85
                    return response_tuple, response_handler
135
110
 
136
111
    def call_expecting_body(self, method, *args):
137
112
        """Call a method and return the result and the protocol object.
138
 
 
 
113
        
139
114
        The body can be read like so::
140
115
 
141
116
            result, smart_protocol = smart_client.call_expecting_body(...)
175
150
                args[0], args[1:], readv_body=body, expect_response_body=True)
176
151
        return (response, response_handler)
177
152
 
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
 
 
184
153
    def remote_path_from_transport(self, transport):
185
154
        """Convert transport into a path suitable for using in a request.
186
 
 
 
155
        
187
156
        Note that the resulting remote path doesn't encode the host name or
188
157
        anything but path, so it is only safe to use it in requests sent over
189
158
        the medium from the matching transport.
190
159
        """
191
 
        return self._medium.remote_path_from_transport(transport)
192
 
 
193
 
 
194
 
class SmartClientHooks(hooks.Hooks):
195
 
 
196
 
    def __init__(self):
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))
203
 
 
204
 
 
205
 
_SmartClient.hooks = SmartClientHooks()
206
 
 
207
 
 
208
 
class CallHookParams(object):
209
 
 
210
 
    def __init__(self, method, args, body, readv_body, medium):
211
 
        self.method = method
212
 
        self.args = args
213
 
        self.body = body
214
 
        self.readv_body = readv_body
215
 
        self.medium = medium
216
 
 
217
 
    def __repr__(self):
218
 
        attrs = dict((k, v) for (k, v) in self.__dict__.iteritems()
219
 
                     if v is not None)
220
 
        return '<%s %r>' % (self.__class__.__name__, attrs)
221
 
 
222
 
    def __eq__(self, other):
223
 
        if type(other) is not type(self):
224
 
            return NotImplemented
225
 
        return self.__dict__ == other.__dict__
226
 
 
227
 
    def __ne__(self, other):
228
 
        return not self == other
 
160
        base = self._base
 
161
        if (base.startswith('bzr+http://') or base.startswith('bzr+https://')
 
162
            or base.startswith('http://') or base.startswith('https://')):
 
163
            medium_base = self._base
 
164
        else:
 
165
            medium_base = urlutils.join(self._base, '/')
 
166
            
 
167
        rel_url = urlutils.relative_url(medium_base, transport.base)
 
168
        return urllib.unquote(rel_url)
 
169