← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart_transport.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_transport.py
1
 
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
657
657
        # wire-to-wire, using the whole stack, with a UTF-8 filename.
658
658
        transport = memory.MemoryTransport('memory:///')
659
659
        utf8_filename = u'testfile\N{INTERROBANG}'.encode('utf-8')
 
660
        # VFS requests use filenames, not raw UTF-8.
 
661
        hpss_path = urlutils.escape(utf8_filename)
660
662
        transport.put_bytes(utf8_filename, 'contents\nof\nfile\n')
661
 
        to_server = StringIO('get\001' + utf8_filename + '\n')
 
663
        to_server = StringIO('get\001' + hpss_path + '\n')
662
664
        from_server = StringIO()
663
665
        server = medium.SmartServerPipeStreamMedium(
664
666
            to_server, from_server, transport)
985
987
    All of these tests are run with a server running on another thread serving
986
988
    a MemoryTransport, and a connection to it already open.
987
989
 
988
 
    the server is obtained by calling self.setUpServer(readonly=False).
 
990
    the server is obtained by calling self.start_server(readonly=False).
989
991
    """
990
992
 
991
 
    def setUpServer(self, readonly=False, backing_transport=None):
 
993
    def start_server(self, readonly=False, backing_transport=None):
992
994
        """Setup the server.
993
995
 
994
996
        :param readonly: Create a readonly server.
998
1000
        # self.vfs_transport_factory etc.
999
1001
        if not backing_transport:
1000
1002
            mem_server = memory.MemoryServer()
1001
 
            mem_server.setUp()
1002
 
            self.addCleanup(mem_server.tearDown)
 
1003
            mem_server.start_server()
 
1004
            self.addCleanup(mem_server.stop_server)
1003
1005
            self.permit_url(mem_server.get_url())
1004
1006
            self.backing_transport = get_transport(mem_server.get_url())
1005
1007
        else:
1019
1021
            del self.transport
1020
1022
        if getattr(self, 'server', None):
1021
1023
            self.server.stop_background_thread()
 
1024
            # XXX: why not .stop_server() -- mbp 20100106
1022
1025
            del self.server
1023
1026
 
1024
1027
 
1026
1029
 
1027
1030
    def test_server_setup_teardown(self):
1028
1031
        """It should be safe to teardown the server with no requests."""
1029
 
        self.setUpServer()
 
1032
        self.start_server()
1030
1033
        server = self.server
1031
1034
        transport = remote.RemoteTCPTransport(self.server.get_url())
1032
1035
        self.tearDownServer()
1034
1037
 
1035
1038
    def test_server_closes_listening_sock_on_shutdown_after_request(self):
1036
1039
        """The server should close its listening socket when it's stopped."""
1037
 
        self.setUpServer()
 
1040
        self.start_server()
1038
1041
        server = self.server
1039
1042
        self.transport.has('.')
1040
1043
        self.tearDownServer()
1049
1052
 
1050
1053
    def setUp(self):
1051
1054
        super(WritableEndToEndTests, self).setUp()
1052
 
        self.setUpServer()
 
1055
        self.start_server()
1053
1056
 
1054
1057
    def test_start_tcp_server(self):
1055
1058
        url = self.server.get_url()
1128
1131
    def test_mkdir_error_readonly(self):
1129
1132
        """TransportNotPossible should be preserved from the backing transport."""
1130
1133
        self._captureVar('BZR_NO_SMART_VFS', None)
1131
 
        self.setUpServer(readonly=True)
 
1134
        self.start_server(readonly=True)
1132
1135
        self.assertRaises(errors.TransportNotPossible, self.transport.mkdir,
1133
1136
            'foo')
1134
1137
 
1144
1147
        self.hook_calls = []
1145
1148
        server.SmartTCPServer.hooks.install_named_hook('server_started',
1146
1149
            self.capture_server_call, None)
1147
 
        self.setUpServer()
 
1150
        self.start_server()
1148
1151
        # at this point, the server will be starting a thread up.
1149
1152
        # there is no indicator at the moment, so bodge it by doing a request.
1150
1153
        self.transport.has('.')
1158
1161
        self.hook_calls = []
1159
1162
        server.SmartTCPServer.hooks.install_named_hook('server_started',
1160
1163
            self.capture_server_call, None)
1161
 
        self.setUpServer(backing_transport=get_transport("."))
 
1164
        self.start_server(backing_transport=get_transport("."))
1162
1165
        # at this point, the server will be starting a thread up.
1163
1166
        # there is no indicator at the moment, so bodge it by doing a request.
1164
1167
        self.transport.has('.')
1174
1177
        self.hook_calls = []
1175
1178
        server.SmartTCPServer.hooks.install_named_hook('server_stopped',
1176
1179
            self.capture_server_call, None)
1177
 
        self.setUpServer()
 
1180
        self.start_server()
1178
1181
        result = [([self.backing_transport.base], self.transport.base)]
1179
1182
        # check the stopping message isn't emitted up front.
1180
1183
        self.assertEqual([], self.hook_calls)
1191
1194
        self.hook_calls = []
1192
1195
        server.SmartTCPServer.hooks.install_named_hook('server_stopped',
1193
1196
            self.capture_server_call, None)
1194
 
        self.setUpServer(backing_transport=get_transport("."))
 
1197
        self.start_server(backing_transport=get_transport("."))
1195
1198
        result = [(
1196
1199
            [self.backing_transport.base, self.backing_transport.external_url()]
1197
1200
            , self.transport.base)]
2890
2893
        self.assertWriteCount(1)
2891
2894
 
2892
2895
    def test_send_response_with_body_stream_flushes_buffers_sometimes(self):
2893
 
        """When there are many chunks (>100), multiple writes will occur rather
 
2896
        """When there are many bytes (>1MB), multiple writes will occur rather
2894
2897
        than buffering indefinitely.
2895
2898
        """
2896
 
        # Construct a response with stream with 40 chunks in it.  Every chunk
2897
 
        # triggers 3 buffered writes, so we expect > 100 buffered writes, but <
2898
 
        # 200.
2899
 
        body_stream = ['chunk %d' % count for count in range(40)]
 
2899
        # Construct a response with stream with ~1.5MB in it. This should
 
2900
        # trigger 2 writes, but not 3
 
2901
        onekib = '12345678' * 128
 
2902
        body_stream = [onekib] * (1024 + 512)
2900
2903
        response = _mod_request.SuccessfulSmartServerResponse(
2901
2904
            ('arg', 'arg'), body_stream=body_stream)
2902
2905
        self.responder.send_response(response)
2903
 
        # The write buffer is flushed every 100 buffered writes, so we expect 2
2904
 
        # actual writes.
2905
2906
        self.assertWriteCount(2)
2906
2907
 
2907
2908