/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/message.py

Merge from bzr.dev.

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
94
87
    """
95
88
 
96
89
    def __init__(self, request_handler, responder):
97
90
        MessageHandler.__init__(self)
98
91
        self.request_handler = request_handler
99
92
        self.responder = responder
100
 
        self.expecting = 'args'
101
 
        self._should_finish_body = False
102
 
        self._response_sent = False
 
93
        self.args_received = False
103
94
 
104
95
    def protocol_error(self, exception):
105
 
        if self.responder.response_sent:
106
 
            # We can only send one response to a request, no matter how many
107
 
            # errors happen while processing it.
108
 
            return
109
96
        self.responder.send_error(exception)
110
97
 
111
98
    def byte_part_received(self, 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,))
 
99
        raise errors.SmartProtocolError(
 
100
            'Unexpected message part: byte(%r)' % (byte,))
125
101
 
126
102
    def structure_part_received(self, structure):
127
 
        if self.expecting == 'args':
128
 
            self._args_received(structure)
129
 
        elif self.expecting == 'error':
130
 
            self._error_received(structure)
131
 
        else:
 
103
        if self.args_received:
132
104
            raise errors.SmartProtocolError(
133
105
                'Unexpected message part: structure(%r)' % (structure,))
134
 
 
135
 
    def _args_received(self, args):
136
 
        self.expecting = 'body'
137
 
        self.request_handler.args_received(args)
 
106
        self.args_received = True
 
107
        self.request_handler.dispatch_command(structure[0], structure[1:])
138
108
        if self.request_handler.finished_reading:
139
 
            self._response_sent = True
140
109
            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)
146
110
 
147
111
    def bytes_part_received(self, bytes):
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()
 
112
        # Note that there's no intrinsic way to distinguish a monolithic body
 
113
        # from a chunk stream.  A request handler knows which it is expecting
 
114
        # (once the args have been received), so it should be able to do the
 
115
        # right thing.
 
116
        self.request_handler.accept_body(bytes)
 
117
        self.request_handler.end_of_body()
162
118
        if not self.request_handler.finished_reading:
163
 
            raise errors.SmartProtocolError(
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)
 
119
            raise SmartProtocolError(
 
120
                "Conventional request body was received, but request handler "
 
121
                "has not finished reading.")
 
122
        self.responder.send_response(self.request_handler.response)
168
123
 
169
124
 
170
125
class ResponseHandler(object):
172
127
 
173
128
    def read_response_tuple(self, expect_body=False):
174
129
        """Reads and returns the response tuple for the current request.
175
 
 
 
130
        
176
131
        :keyword expect_body: a boolean indicating if a body is expected in the
177
132
            response.  Some protocol versions needs this information to know
178
133
            when a response is finished.  If False, read_body_bytes should
243
198
        self._bytes_parts.append(bytes)
244
199
 
245
200
    def structure_part_received(self, structure):
246
 
        if type(structure) is not tuple:
 
201
        if type(structure) is not list:
247
202
            raise errors.SmartProtocolError(
248
203
                'Args structure is not a sequence: %r' % (structure,))
 
204
        structure = tuple(structure)
249
205
        if not self._body_started:
250
206
            if self.args is not None:
251
207
                raise errors.SmartProtocolError(
277
233
        bytes = self._medium_request.read_bytes(next_read_size)
278
234
        if bytes == '':
279
235
            # end of file encountered reading from server
280
 
            if 'hpss' in debug.debug_flags:
281
 
                mutter(
282
 
                    'decoder state: buf[:10]=%r, state_accept=%s',
283
 
                    self._protocol_decoder._get_in_buffer()[:10],
284
 
                    self._protocol_decoder.state_accept.__name__)
285
236
            raise errors.ConnectionReset(
286
 
                "Unexpected end of message. "
287
 
                "Please check connectivity and permissions, and report a bug "
288
 
                "if problems persist.")
 
237
                "please check connectivity and permissions",
 
238
                "(and try -Dhpss if further diagnosis is required)")
289
239
        self._protocol_decoder.accept_bytes(bytes)
290
240
 
291
 
    def protocol_error(self, exception):
292
 
        # Whatever the error is, we're done with this request.
293
 
        self.finished_reading = True
294
 
        self._medium_request.finished_reading()
295
 
        raise
296
 
 
297
241
    def read_response_tuple(self, expect_body=False):
298
242
        """Read a response tuple from the wire."""
299
243
        self._wait_for_response_args()
308
252
 
309
253
    def read_body_bytes(self, count=-1):
310
254
        """Read bytes from the body, decoding into a byte stream.
311
 
 
312
 
        We read all bytes at once to ensure we've checked the trailer for
 
255
        
 
256
        We read all bytes at once to ensure we've checked the trailer for 
313
257
        errors, and then feed the buffer back as read_body_bytes is called.
314
258
 
315
259
        Like the builtin file.read in Python, a count of -1 (the default) means
330
274
        while not self.finished_reading:
331
275
            while self._bytes_parts:
332
276
                bytes_part = self._bytes_parts.popleft()
333
 
                if 'hpssdetail' in debug.debug_flags:
 
277
                if 'hpss' in debug.debug_flags:
334
278
                    mutter('              %d byte part read', len(bytes_part))
335
279
                yield bytes_part
336
280
            self._read_more()
353
297
        raise errors.LockContention('(remote lock)')
354
298
    elif error_name == 'LockFailed':
355
299
        raise errors.LockFailed(*error_args[:2])
356
 
    elif error_name == 'FileExists':
357
 
        raise errors.FileExists(error_args[0])
358
 
    elif error_name == 'NoSuchFile':
359
 
        raise errors.NoSuchFile(error_args[0])
360
300
    else:
361
301
        raise errors.ErrorFromSmartServer(error_tuple)