← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/protocol.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/protocol.py
109
109
        for start, length in offsets:
110
110
            txt.append('%d,%d' % (start, length))
111
111
        return '\n'.join(txt)
112
 
        
 
112
 
113
113
 
114
114
class SmartServerRequestProtocolOne(SmartProtocolBase):
115
115
    """Server-side encoding and decoding logic for smart version 1."""
116
 
    
 
116
 
117
117
    def __init__(self, backing_transport, write_func, root_client_path='/'):
118
118
        self._backing_transport = backing_transport
119
119
        self._root_client_path = root_client_path
127
127
 
128
128
    def accept_bytes(self, bytes):
129
129
        """Take bytes, and advance the internal state machine appropriately.
130
 
        
 
130
 
131
131
        :param bytes: must be a byte string
132
132
        """
133
133
        if not isinstance(bytes, str):
169
169
 
170
170
        if self._has_dispatched:
171
171
            if self._finished:
172
 
                # nothing to do.XXX: this routine should be a single state 
 
172
                # nothing to do.XXX: this routine should be a single state
173
173
                # machine too.
174
174
                self.unused_data += self.in_buffer
175
175
                self.in_buffer = ''
211
211
 
212
212
    def _write_protocol_version(self):
213
213
        """Write any prefixes this protocol requires.
214
 
        
 
214
 
215
215
        Version one doesn't send protocol versions.
216
216
        """
217
217
 
234
234
 
235
235
class SmartServerRequestProtocolTwo(SmartServerRequestProtocolOne):
236
236
    r"""Version two of the server side of the smart protocol.
237
 
   
 
237
 
238
238
    This prefixes responses with the value of RESPONSE_VERSION_TWO.
239
239
    """
240
240
 
250
250
 
251
251
    def _write_protocol_version(self):
252
252
        r"""Write any prefixes this protocol requires.
253
 
        
 
253
 
254
254
        Version two sends the value of RESPONSE_VERSION_TWO.
255
255
        """
256
256
        self._write_func(self.response_marker)
412
412
        self.chunks = collections.deque()
413
413
        self.error = False
414
414
        self.error_in_progress = None
415
 
    
 
415
 
416
416
    def next_read_size(self):
417
417
        # Note: the shortest possible chunk is 2 bytes: '0\n', and the
418
418
        # end-of-body marker is 4 bytes: 'END\n'.
506
506
                self.chunks.append(self.chunk_in_progress)
507
507
            self.chunk_in_progress = None
508
508
            self.state_accept = self._state_accept_expecting_length
509
 
        
 
509
 
510
510
    def _state_accept_reading_unused(self):
511
511
        self.unused_data += self._get_in_buffer()
512
512
        self._in_buffer_list = []
514
514
 
515
515
class LengthPrefixedBodyDecoder(_StatefulDecoder):
516
516
    """Decodes the length-prefixed bulk data."""
517
 
    
 
517
 
518
518
    def __init__(self):
519
519
        _StatefulDecoder.__init__(self)
520
520
        self.state_accept = self._state_accept_expecting_length
521
521
        self.state_read = self._state_read_no_data
522
522
        self._body = ''
523
523
        self._trailer_buffer = ''
524
 
    
 
524
 
525
525
    def next_read_size(self):
526
526
        if self.bytes_left is not None:
527
527
            # Ideally we want to read all the remainder of the body and the
537
537
        else:
538
538
            # Reading excess data.  Either way, 1 byte at a time is fine.
539
539
            return 1
540
 
        
 
540
 
541
541
    def read_pending_data(self):
542
542
        """Return any pending data that has been decoded."""
543
543
        return self.state_read()
564
564
                self._body = self._body[:self.bytes_left]
565
565
            self.bytes_left = None
566
566
            self.state_accept = self._state_accept_reading_trailer
567
 
        
 
567
 
568
568
    def _state_accept_reading_trailer(self):
569
569
        self._trailer_buffer += self._get_in_buffer()
570
570
        self._set_in_buffer(None)
574
574
            self.unused_data = self._trailer_buffer[len('done\n'):]
575
575
            self.state_accept = self._state_accept_reading_unused
576
576
            self.finished_reading = True
577
 
    
 
577
 
578
578
    def _state_accept_reading_unused(self):
579
579
        self.unused_data += self._get_in_buffer()
580
580
        self._set_in_buffer(None)
729
729
    def _response_is_unknown_method(self, result_tuple):
730
730
        """Raise UnexpectedSmartServerResponse if the response is an 'unknonwn
731
731
        method' response to the request.
732
 
        
 
732
 
733
733
        :param response: The response from a smart client call_expecting_body
734
734
            call.
735
735
        :param verb: The verb used in that call.
742
742
            # The response will have no body, so we've finished reading.
743
743
            self._request.finished_reading()
744
744
            raise errors.UnknownSmartMethod(self._last_verb)
745
 
        
 
745
 
746
746
    def read_body_bytes(self, count=-1):
747
747
        """Read bytes from the body, decoding into a byte stream.
748
 
        
749
 
        We read all bytes at once to ensure we've checked the trailer for 
 
748
 
 
749
        We read all bytes at once to ensure we've checked the trailer for
750
750
        errors, and then feed the buffer back as read_body_bytes is called.
751
751
        """
752
752
        if self._body_buffer is not None:
790
790
 
791
791
    def _write_protocol_version(self):
792
792
        """Write any prefixes this protocol requires.
793
 
        
 
793
 
794
794
        Version one doesn't send protocol versions.
795
795
        """
796
796
 
797
797
 
798
798
class SmartClientRequestProtocolTwo(SmartClientRequestProtocolOne):
799
799
    """Version two of the client side of the smart protocol.
800
 
    
 
800
 
801
801
    This prefixes the request with the value of REQUEST_VERSION_TWO.
802
802
    """
803
803
 
831
831
 
832
832
    def _write_protocol_version(self):
833
833
        """Write any prefixes this protocol requires.
834
 
        
 
834
 
835
835
        Version two sends the value of REQUEST_VERSION_TWO.
836
836
        """
837
837
        self._request.accept_bytes(self.request_marker)
985
985
            self.message_handler.headers_received(decoded)
986
986
        except:
987
987
            raise errors.SmartMessageHandlerError(sys.exc_info())
988
 
    
 
988
 
989
989
    def _state_accept_expecting_message_part(self):
990
990
        message_part_kind = self._extract_single_byte()
991
991
        if message_part_kind == 'o':
1077
1077
        for start, length in offsets:
1078
1078
            txt.append('%d,%d' % (start, length))
1079
1079
        return '\n'.join(txt)
1080
 
        
 
1080
 
1081
1081
    def _write_protocol_version(self):
1082
1082
        self._write_func(MESSAGE_VERSION_THREE)
1083
1083
 
1162
1162
                self._write_prefixed_body(chunk)
1163
1163
                self.flush()
1164
1164
        self._write_end()
1165
 
        
 
1165
 
1166
1166
 
1167
1167
class ProtocolThreeRequester(_ProtocolThreeEncoder, Requester):
1168
1168
 
1173
1173
 
1174
1174
    def set_headers(self, headers):
1175
1175
        self._headers = headers.copy()
1176
 
        
 
1176
 
1177
1177
    def call(self, *args):
1178
1178
        if 'hpss' in debug.debug_flags:
1179
1179
            mutter('hpss call:   %s', repr(args)[1:-1])