← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/message.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/message.py
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 collections
18
18
from cStringIO import StringIO
36
36
 
37
37
    def headers_received(self, headers):
38
38
        """Called when message headers are received.
39
 
        
 
39
 
40
40
        This default implementation just stores them in self.headers.
41
41
        """
42
42
        self.headers = headers
67
67
 
68
68
    def protocol_error(self, exception):
69
69
        """Called when there is a protocol decoding error.
70
 
        
 
70
 
71
71
        The default implementation just re-raises the exception.
72
72
        """
73
73
        raise
74
 
    
 
74
 
75
75
    def end_received(self):
76
76
        """Called when the end of the message is received."""
77
77
        # No-op by default.
84
84
    "Conventional" is used in the sense described in
85
85
    doc/developers/network-protocol.txt: a simple message with arguments and an
86
86
    optional body.
 
87
 
 
88
    Possible states:
 
89
     * args: expecting args
 
90
     * body: expecting body (terminated by receiving a post-body status)
 
91
     * error: expecting post-body error
 
92
     * end: expecting end of message
 
93
     * nothing: finished
87
94
    """
88
95
 
89
96
    def __init__(self, request_handler, responder):
90
97
        MessageHandler.__init__(self)
91
98
        self.request_handler = request_handler
92
99
        self.responder = responder
93
 
        self.args_received = False
 
100
        self.expecting = 'args'
 
101
        self._should_finish_body = False
 
102
        self._response_sent = False
94
103
 
95
104
    def protocol_error(self, exception):
96
105
        if self.responder.response_sent:
100
109
        self.responder.send_error(exception)
101
110
 
102
111
    def byte_part_received(self, byte):
103
 
        raise errors.SmartProtocolError(
104
 
            'Unexpected message part: byte(%r)' % (byte,))
 
112
        if self.expecting == 'body':
 
113
            if byte == 'S':
 
114
                # Success.  Nothing more to come except the end of message.
 
115
                self.expecting = 'end'
 
116
            elif byte == 'E':
 
117
                # Error.  Expect an error structure.
 
118
                self.expecting = 'error'
 
119
            else:
 
120
                raise errors.SmartProtocolError(
 
121
                    'Non-success status byte in request body: %r' % (byte,))
 
122
        else:
 
123
            raise errors.SmartProtocolError(
 
124
                'Unexpected message part: byte(%r)' % (byte,))
105
125
 
106
126
    def structure_part_received(self, structure):
107
 
        if self.args_received:
 
127
        if self.expecting == 'args':
 
128
            self._args_received(structure)
 
129
        elif self.expecting == 'error':
 
130
            self._error_received(structure)
 
131
        else:
108
132
            raise errors.SmartProtocolError(
109
133
                'Unexpected message part: structure(%r)' % (structure,))
110
 
        self.args_received = True
111
 
        self.request_handler.dispatch_command(structure[0], structure[1:])
 
134
 
 
135
    def _args_received(self, args):
 
136
        self.expecting = 'body'
 
137
        self.request_handler.args_received(args)
112
138
        if self.request_handler.finished_reading:
 
139
            self._response_sent = True
113
140
            self.responder.send_response(self.request_handler.response)
 
141
            self.expecting = 'end'
 
142
 
 
143
    def _error_received(self, error_args):
 
144
        self.expecting = 'end'
 
145
        self.request_handler.post_body_error_received(error_args)
114
146
 
115
147
    def bytes_part_received(self, bytes):
116
 
        # Note that there's no intrinsic way to distinguish a monolithic body
117
 
        # from a chunk stream.  A request handler knows which it is expecting
118
 
        # (once the args have been received), so it should be able to do the
119
 
        # right thing.
120
 
        self.request_handler.accept_body(bytes)
121
 
        self.request_handler.end_of_body()
 
148
        if self.expecting == 'body':
 
149
            self._should_finish_body = True
 
150
            self.request_handler.accept_body(bytes)
 
151
        else:
 
152
            raise errors.SmartProtocolError(
 
153
                'Unexpected message part: bytes(%r)' % (bytes,))
 
154
 
 
155
    def end_received(self):
 
156
        if self.expecting not in ['body', 'end']:
 
157
            raise errors.SmartProtocolError(
 
158
                'End of message received prematurely (while expecting %s)'
 
159
                % (self.expecting,))
 
160
        self.expecting = 'nothing'
 
161
        self.request_handler.end_received()
122
162
        if not self.request_handler.finished_reading:
123
163
            raise errors.SmartProtocolError(
124
 
                "Conventional request body was received, but request handler "
125
 
                "has not finished reading.")
126
 
        self.responder.send_response(self.request_handler.response)
 
164
                "Complete conventional request was received, but request "
 
165
                "handler has not finished reading.")
 
166
        if not self._response_sent:
 
167
            self.responder.send_response(self.request_handler.response)
127
168
 
128
169
 
129
170
class ResponseHandler(object):
131
172
 
132
173
    def read_response_tuple(self, expect_body=False):
133
174
        """Reads and returns the response tuple for the current request.
134
 
        
 
175
 
135
176
        :keyword expect_body: a boolean indicating if a body is expected in the
136
177
            response.  Some protocol versions needs this information to know
137
178
            when a response is finished.  If False, read_body_bytes should
202
243
        self._bytes_parts.append(bytes)
203
244
 
204
245
    def structure_part_received(self, structure):
205
 
        if type(structure) is not list:
 
246
        if type(structure) is not tuple:
206
247
            raise errors.SmartProtocolError(
207
248
                'Args structure is not a sequence: %r' % (structure,))
208
 
        structure = tuple(structure)
209
249
        if not self._body_started:
210
250
            if self.args is not None:
211
251
                raise errors.SmartProtocolError(
240
280
            if 'hpss' in debug.debug_flags:
241
281
                mutter(
242
282
                    'decoder state: buf[:10]=%r, state_accept=%s',
243
 
                    self._protocol_decoder._in_buffer[:10],
 
283
                    self._protocol_decoder._get_in_buffer()[:10],
244
284
                    self._protocol_decoder.state_accept.__name__)
245
285
            raise errors.ConnectionReset(
246
 
                "please check connectivity and permissions",
247
 
                "(and try -Dhpss if further diagnosis is required)")
 
286
                "Unexpected end of message. "
 
287
                "Please check connectivity and permissions, and report a bug "
 
288
                "if problems persist.")
248
289
        self._protocol_decoder.accept_bytes(bytes)
249
290
 
250
291
    def protocol_error(self, exception):
252
293
        self.finished_reading = True
253
294
        self._medium_request.finished_reading()
254
295
        raise
255
 
        
 
296
 
256
297
    def read_response_tuple(self, expect_body=False):
257
298
        """Read a response tuple from the wire."""
258
299
        self._wait_for_response_args()
262
303
            mutter('   result:   %r', self.args)
263
304
        if self.status == 'E':
264
305
            self._wait_for_response_end()
265
 
            _translate_error(self.args)
 
306
            _raise_smart_server_error(self.args)
266
307
        return tuple(self.args)
267
308
 
268
309
    def read_body_bytes(self, count=-1):
269
310
        """Read bytes from the body, decoding into a byte stream.
270
 
        
271
 
        We read all bytes at once to ensure we've checked the trailer for 
 
311
 
 
312
        We read all bytes at once to ensure we've checked the trailer for
272
313
        errors, and then feed the buffer back as read_body_bytes is called.
273
314
 
274
315
        Like the builtin file.read in Python, a count of -1 (the default) means
289
330
        while not self.finished_reading:
290
331
            while self._bytes_parts:
291
332
                bytes_part = self._bytes_parts.popleft()
292
 
                if 'hpss' in debug.debug_flags:
 
333
                if 'hpssdetail' in debug.debug_flags:
293
334
                    mutter('              %d byte part read', len(bytes_part))
294
335
                yield bytes_part
295
336
            self._read_more()
296
337
        if self._body_stream_status == 'E':
297
 
            _translate_error(self._body_error_args)
 
338
            _raise_smart_server_error(self._body_error_args)
298
339
 
299
340
    def cancel_read_body(self):
300
341
        self._wait_for_response_end()
301
342
 
302
343
 
303
 
def _translate_error(error_tuple):
304
 
    # Many exceptions need some state from the requestor to be properly
305
 
    # translated (e.g. they need a branch object).  So this only translates a
306
 
    # few errors, and the rest are turned into a generic ErrorFromSmartServer.
307
 
    error_name = error_tuple[0]
308
 
    error_args = error_tuple[1:]
309
 
    if error_name == 'UnknownMethod':
310
 
        raise errors.UnknownSmartMethod(error_args[0])
311
 
    if error_name == 'LockContention':
312
 
        raise errors.LockContention('(remote lock)')
313
 
    elif error_name == 'LockFailed':
314
 
        raise errors.LockFailed(*error_args[:2])
315
 
    else:
316
 
        raise errors.ErrorFromSmartServer(error_tuple)
 
344
def _raise_smart_server_error(error_tuple):
 
345
    """Raise exception based on tuple received from smart server
 
346
 
 
347
    Specific error translation is handled by bzrlib.remote._translate_error
 
348
    """
 
349
    if error_tuple[0] == 'UnknownMethod':
 
350
        raise errors.UnknownSmartMethod(error_tuple[1])
 
351
    raise errors.ErrorFromSmartServer(error_tuple)