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

  • Committer: Andrew Bennetts
  • Date: 2008-02-25 02:24:19 UTC
  • mto: (3245.4.1 Version 3 implementation.)
  • mto: This revision was merged to the branch mainline in revision 3428.
  • Revision ID: andrew.bennetts@canonical.com-20080225022419-b8en5fsed6vez0gv
call_with_body_bytes now works with v3 (e.g. test_copy_content_remote_to_local passes).  Lots of debugging cruft, though.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/protocol.py
250
250
    have been received.
251
251
    """
252
252
 
 
253
    def __init__(self, count=None):
 
254
        self.count = count
 
255
 
253
256
 
254
257
class _StatefulDecoder(object):
255
258
 
270
273
        # accept_bytes is allowed to change the state
271
274
        current_state = self.state_accept
272
275
        try:
 
276
            pr('invoking state_accept %s' %
 
277
                    (self.state_accept.im_func.__name__[len('_state_accept_'):],))
273
278
            self.state_accept(bytes)
274
279
            while current_state != self.state_accept:
275
280
                current_state = self.state_accept
 
281
                pr('invoking state_accept %s' %
 
282
                        (self.state_accept.im_func.__name__[len('_state_accept_'):],))
276
283
                self.state_accept('')
277
284
        except _NeedMoreBytes:
278
 
            pass
 
285
            raise
 
286
            #pass
279
287
 
280
288
 
281
289
class ChunkedBodyDecoder(_StatefulDecoder):
687
695
        self.has_dispatched = False
688
696
        # Initial state
689
697
        self._in_buffer = ''
 
698
        self._number_needed_bytes = 4
690
699
        self.state_accept = self._state_accept_expecting_headers
691
700
 
692
701
        self.request_handler = self.message_handler = message_handler
697
706
#        self._body_decoder = None
698
707
 
699
708
    def accept_bytes(self, bytes):
 
709
        pr('......')
 
710
#        if 'put_non_atomic' in bytes:
 
711
#            import pdb; pdb.set_trace()
 
712
        def summarise_buf():
 
713
            if self._in_buffer is None:
 
714
                buf_summary = 'None'
 
715
            elif len(self._in_buffer) <= 6:
 
716
                buf_summary = repr(self._in_buffer)
 
717
            else:
 
718
                buf_summary = repr(self._in_buffer[:3] + '...')
 
719
            return buf_summary
 
720
        handler_name = self.message_handler.__class__.__name__
 
721
        handler_name = handler_name[len('Conventional'):-len('Handler')]
 
722
        state_now = self.state_accept.im_func.__name__[len('_state_accept_'):]
 
723
        buf_now = summarise_buf()
 
724
        #from pprint import pprint; pprint([bytes, self.__dict__])
 
725
        self._number_needed_bytes = None
700
726
        try:
701
727
            _StatefulDecoder.accept_bytes(self, bytes)
 
728
        except _NeedMoreBytes, e:
 
729
            #print '(need more bytes: %r)' % e.count
 
730
            self._number_needed_bytes = e.count
702
731
        except KeyboardInterrupt:
703
732
            raise
704
733
        except Exception, exception:
707
736
            self.message_handler.protocol_error(exception)
708
737
            #self._send_response(request.FailedSmartServerResponse(
709
738
            #    ('error', str(exception))))
 
739
        pr('%s in %s(%s), got %r --> %s(%s)' % (
 
740
            handler_name, state_now, buf_now, bytes,
 
741
            self.state_accept.im_func.__name__[len('_state_accept_'):],
 
742
            summarise_buf()))
 
743
        pr('~~~~~~')
710
744
 
711
745
    def _extract_length_prefixed_bytes(self):
712
746
        if len(self._in_buffer) < 4:
713
747
            # A length prefix by itself is 4 bytes, and we don't even have that
714
748
            # many yet.
715
 
            raise _NeedMoreBytes()
 
749
            raise _NeedMoreBytes(4)
716
750
        (length,) = struct.unpack('!L', self._in_buffer[:4])
717
751
        end_of_bytes = 4 + length
718
752
        if len(self._in_buffer) < end_of_bytes:
719
753
            # We haven't yet read as many bytes as the length-prefix says there
720
754
            # are.
721
 
            raise _NeedMoreBytes()
 
755
            raise _NeedMoreBytes(end_of_bytes)
722
756
        # Extract the bytes from the buffer.
723
757
        bytes = self._in_buffer[4:end_of_bytes]
724
758
        self._in_buffer = self._in_buffer[end_of_bytes:]
751
785
        self.state_accept = self._state_accept_expecting_message_part
752
786
    
753
787
    def _state_accept_expecting_message_part(self, bytes):
 
788
        #import sys; print >> sys.stderr, 'msg part bytes:', repr(bytes)
754
789
        self._in_buffer += bytes
755
790
        message_part_kind = self._extract_single_byte()
756
791
        if message_part_kind == 'o':
764
799
        else:
765
800
            raise errors.SmartProtocolError(
766
801
                'Bad message kind byte: %r' % (message_part_kind,))
 
802
        #import sys; print >> sys.stderr, 'state:', self.state_accept, '_in_buffer:', repr(self._in_buffer)
767
803
 
768
804
    def _state_accept_expecting_one_byte(self, bytes):
769
805
        self._in_buffer += bytes
775
811
        # XXX: this should not buffer whole message part, but instead deliver
776
812
        # the bytes as they arrive.
777
813
        self._in_buffer += bytes
778
 
        bytes = self._extract_length_prefixed_bytes()
779
 
        self.message_handler.bytes_part_received(bytes)
 
814
        prefixed_bytes = self._extract_length_prefixed_bytes()
 
815
        self.message_handler.bytes_part_received(prefixed_bytes)
780
816
        self.state_accept = self._state_accept_expecting_message_part
781
817
 
782
818
    def _state_accept_expecting_structure(self, bytes):
786
822
        self.state_accept = self._state_accept_expecting_message_part
787
823
 
788
824
    def done(self):
 
825
        #import sys; print >> sys.stderr, 'Done!', repr(self._in_buffer)
789
826
        self.unused_data = self._in_buffer
790
827
        self._in_buffer = None
791
828
        self.state_accept = self._state_accept_reading_unused
804
841
        if self.state_accept == self._state_accept_reading_unused:
805
842
            return 0
806
843
        else:
807
 
            return 1 # XXX !!!
 
844
            if self._number_needed_bytes is not None:
 
845
                return self._number_needed_bytes - len(self._in_buffer)
 
846
            else:
 
847
                return 1 # XXX !!!
808
848
 
809
849
 
810
850
class SmartServerRequestProtocolThree(_ProtocolThreeBase):
923
963
        self._write_protocol_version()
924
964
        self._write_headers(headers)
925
965
        self._write_args(args)
 
966
        import pdb; pdb.set_trace()
926
967
        self._write_prefixed_body(body)
927
968
        self._write_end()
928
969
        self._request.finished_writing()
977
1018
    def __init__(self, write_func):
978
1019
        import sys
979
1020
        def wf(bytes):
980
 
            print >> sys.stderr, 'writing:', repr(bytes)
 
1021
            pr('writing:', repr(bytes))
981
1022
            return write_func(bytes)
982
 
        self._write_func = write_func
 
1023
        self._write_func = wf
983
1024
 
984
1025
    def _write_protocol_version(self):
985
1026
        self._write_func(MESSAGE_VERSION_THREE)
1020
1061
        self.response_sent = False
1021
1062
 
1022
1063
    def send_error(self, exception):
1023
 
        #import sys
1024
 
        #print >> sys.stderr, 'exc:', str(exception); return #XXX
 
1064
        #import sys; print >> sys.stderr, 'exc:', str(exception); return #XXX
1025
1065
        assert not self.response_sent
1026
1066
        self.response_sent = True
1027
1067
        self._write_headers()
1030
1070
        self._write_end()
1031
1071
 
1032
1072
    def send_response(self, response):
1033
 
        #import sys
1034
 
        #print >> sys.stderr, 'rsp:', str(response)
 
1073
        #import sys; print >> sys.stderr, 'rsp:', str(response)
1035
1074
        assert not self.response_sent
1036
1075
        self.response_sent = True
1037
1076
        self._write_headers()
1101
1140
                mutter('                  (to %s)', self._request._medium._path)
1102
1141
            mutter('              %d bytes', len(body))
1103
1142
            self._request_start_time = time.time()
 
1143
        pr('call_with_body_bytes: %r, %r' % (args, body))
1104
1144
        self._write_protocol_version()
1105
1145
        self._write_headers(headers)
1106
1146
        self._write_structure(args)
1107
1147
        self._write_prefixed_body(body)
1108
1148
        self._write_end()
1109
 
        self._request.finished_writing()
 
1149
        self._medium_request.finished_writing()
1110
1150
 
1111
1151
    def call_with_body_readv_array(self, args, body, headers=None):
1112
1152
        """Make a remote call with a readv array.
1153
1193
#        return self.response_handler.prefixed_body.read(count)
1154
1194
 
1155
1195
 
 
1196
from thread import get_ident
 
1197
def pr(*args):
 
1198
    return
 
1199
    print '%x' % get_ident(),
 
1200
    for arg in args:
 
1201
        print arg,
 
1202
    print