~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_test_server.py

  • Committer: Jelmer Vernooij
  • Date: 2016-04-03 16:32:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6617.
  • Revision ID: jelmer@jelmer.uk-20160403163231-h72bo0uyek2gikw0
Don't put French text in doc/en/user-reference when LANGUAGE=fr_CH.UTF_8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2010, 2011 Canonical Ltd
 
1
# Copyright (C) 2010, 2011, 2016 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
19
19
import SocketServer
20
20
import threading
21
21
 
 
22
 
22
23
from bzrlib import (
23
24
    osutils,
24
25
    tests,
30
31
load_tests = load_tests_apply_scenarios
31
32
 
32
33
 
 
34
def portable_socket_pair():
 
35
    """Return a pair of TCP sockets connected to each other.
 
36
 
 
37
    Unlike socket.socketpair, this should work on Windows.
 
38
    """
 
39
    listen_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
40
    listen_sock.bind(('127.0.0.1', 0))
 
41
    listen_sock.listen(1)
 
42
    client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
43
    client_sock.connect(listen_sock.getsockname())
 
44
    server_sock, addr = listen_sock.accept()
 
45
    listen_sock.close()
 
46
    return server_sock, client_sock
 
47
 
 
48
 
33
49
class TCPClient(object):
34
50
 
35
51
    def __init__(self):
61
77
        return self.sock.recv(bufsize)
62
78
 
63
79
 
64
 
class TCPConnectionHandler(SocketServer.StreamRequestHandler):
 
80
class TCPConnectionHandler(SocketServer.BaseRequestHandler):
65
81
 
66
82
    def handle(self):
67
83
        self.done = False
69
85
        while not self.done:
70
86
            self.handle_connection()
71
87
 
 
88
    def readline(self):
 
89
        # TODO: We should be buffering any extra data sent, etc. However, in
 
90
        #       practice, we don't send extra content, so we haven't bothered
 
91
        #       to implement it yet.
 
92
        req = self.request.recv(4096)
 
93
        # An empty string is allowed, to indicate the end of the connection
 
94
        if not req or (req.endswith('\n') and req.count('\n') == 1):
 
95
            return req
 
96
        raise ValueError('[%r] not a simple line' % (req,))
 
97
 
72
98
    def handle_connection(self):
73
 
        req = self.rfile.readline()
 
99
        req = self.readline()
74
100
        if not req:
75
101
            self.done = True
76
102
        elif req == 'ping\n':
77
 
            self.wfile.write('pong\n')
 
103
            self.request.sendall('pong\n')
78
104
        else:
79
105
            raise ValueError('[%s] not understood' % req)
80
106
 
81
107
 
82
108
class TestTCPServerInAThread(tests.TestCase):
83
109
 
84
 
    scenarios = [ 
 
110
    scenarios = [
85
111
        (name, {'server_class': getattr(test_server, name)})
86
112
        for name in
87
113
        ('TestingTCPServer', 'TestingThreadingTCPServer')]
91
117
            self.server_class = server_class
92
118
        if connection_handler_class is None:
93
119
            connection_handler_class = TCPConnectionHandler
94
 
        server =  test_server.TestingTCPServerInAThread(
 
120
        server = test_server.TestingTCPServerInAThread(
95
121
            ('localhost', 0), self.server_class, connection_handler_class)
96
122
        server.start_server()
97
123
        self.addCleanup(server.stop_server)
107
133
 
108
134
    def assertClientAddr(self, client, server, conn_rank):
109
135
        conn = self.get_server_connection(server, conn_rank)
110
 
        self.assertEquals(client.sock.getsockname(), conn[1])
 
136
        self.assertEqual(client.sock.getsockname(), conn[1])
111
137
 
112
138
    def test_start_stop(self):
113
139
        server = self.get_server()
126
152
        self.assertIs(None, client.write('ping\n'))
127
153
        resp = client.read()
128
154
        self.assertClientAddr(client, server, 0)
129
 
        self.assertEquals('pong\n', resp)
 
155
        self.assertEqual('pong\n', resp)
130
156
 
131
157
    def test_server_fails_to_start(self):
132
158
        class CantStart(Exception):
155
181
        # The server won't fail until a client connect
156
182
        client = self.get_client()
157
183
        client.connect((server.host, server.port))
 
184
        # We make sure the server wants to handle a request, but the request is
 
185
        # guaranteed to fail. However, the server should make sure that the
 
186
        # connection gets closed, and stop_server should then raise the
 
187
        # original exception.
 
188
        client.write('ping\n')
158
189
        try:
159
 
            # Now we must force the server to answer by sending the request and
160
 
            # waiting for some answer. But since we don't control when the
161
 
            # server thread will be given cycles, we don't control either
162
 
            # whether our reads or writes may hang.
163
 
            client.sock.settimeout(0.1)
164
 
            client.write('ping\n')
165
 
            client.read()
166
 
        except socket.error:
167
 
            pass
 
190
            self.assertEqual('', client.read())
 
191
        except socket.error, e:
 
192
            # On Windows, failing during 'handle' means we get
 
193
            # 'forced-close-of-connection'. Possibly because we haven't
 
194
            # processed the write request before we close the socket.
 
195
            WSAECONNRESET = 10054
 
196
            if e.errno in (WSAECONNRESET,):
 
197
                pass
168
198
        # Now the server has raised the exception in its own thread
169
199
        self.assertRaises(CantConnect, server.stop_server)
170
200
 
182
212
 
183
213
        class FailingDuringResponseHandler(TCPConnectionHandler):
184
214
 
 
215
            # We use 'request' instead of 'self' below because the test matters
 
216
            # more and we need a container to properly set connection_thread.
185
217
            def handle_connection(request):
186
 
                req = request.rfile.readline()
 
218
                req = request.readline()
187
219
                # Capture the thread and make it use 'caught' so we can wait on
188
 
                # the even that will be set when the exception is caught. We
 
220
                # the event that will be set when the exception is caught. We
189
221
                # also capture the thread to know where to look.
190
222
                self.connection_thread = threading.currentThread()
191
223
                self.connection_thread.set_sync_event(caught)
198
230
        client.write('ping\n')
199
231
        # Wait for the exception to be caught
200
232
        caught.wait()
 
233
        self.assertEqual('', client.read()) # connection closed
201
234
        # Check that the connection thread did catch the exception,
202
235
        # http://pad.lv/869366 was wrongly checking the server thread which
203
236
        # works for TestingTCPServer where the connection is handled in the
204
 
        # same thread than the server one but is racy for
205
 
        # TestingThreadingTCPServer where the server thread may be in a
206
 
        # blocking accept() call (or not).
207
 
        try:
208
 
            self.connection_thread.pending_exception()
209
 
        except FailToRespond:
210
 
            # Great, the test succeeded
211
 
            pass
212
 
        else:
213
 
            # If the exception is not in the connection thread anymore, it's in
214
 
            # the server's one. 
215
 
            server.server.stopped.wait()
216
 
            # The exception is available now
217
 
            self.assertRaises(FailToRespond, server.pending_exception)
 
237
        # same thread than the server one but was racy for
 
238
        # TestingThreadingTCPServer. Since the connection thread detaches
 
239
        # itself before handling the request, we are guaranteed that the
 
240
        # exception won't leak into the server thread anymore.
 
241
        self.assertRaises(FailToRespond,
 
242
                          self.connection_thread.pending_exception)
218
243
 
219
244
    def test_exception_swallowed_while_serving(self):
220
245
        # We need to ensure the exception has been caught
229
254
 
230
255
        class FailingWhileServingConnectionHandler(TCPConnectionHandler):
231
256
 
 
257
            # We use 'request' instead of 'self' below because the test matters
 
258
            # more and we need a container to properly set connection_thread.
232
259
            def handle(request):
233
260
                # Capture the thread and make it use 'caught' so we can wait on
234
 
                # the even that will be set when the exception is caught. We
 
261
                # the event that will be set when the exception is caught. We
235
262
                # also capture the thread to know where to look.
236
263
                self.connection_thread = threading.currentThread()
237
264
                self.connection_thread.set_sync_event(caught)
239
266
 
240
267
        server = self.get_server(
241
268
            connection_handler_class=FailingWhileServingConnectionHandler)
 
269
        self.assertEqual(True, server.server.serving)
242
270
        # Install the exception swallower
243
271
        server.set_ignored_exceptions(CantServe)
244
272
        client = self.get_client()
246
274
        client.connect((server.host, server.port))
247
275
        # Wait for the exception to be caught
248
276
        caught.wait()
 
277
        self.assertEqual('', client.read()) # connection closed
249
278
        # The connection wasn't served properly but the exception should have
250
279
        # been swallowed (see test_server_crash_while_responding remark about
251
280
        # http://pad.lv/869366 explaining why we can't check the server thread
252
281
        # here). More precisely, the exception *has* been caught and captured
253
282
        # but it is cleared when joining the thread (or trying to acquire the
254
283
        # exception) and as such won't propagate to the server thread.
255
 
        self.connection_thread.pending_exception()
256
 
        server.pending_exception()
 
284
        self.assertIs(None, self.connection_thread.pending_exception())
 
285
        self.assertIs(None, server.pending_exception())
 
286
 
 
287
    def test_handle_request_closes_if_it_doesnt_process(self):
 
288
        server = self.get_server()
 
289
        client = self.get_client()
 
290
        server.server.serving = False
 
291
        client.connect((server.host, server.port))
 
292
        self.assertEqual('', client.read())
 
293
 
 
294
 
 
295
class TestTestingSmartServer(tests.TestCase):
 
296
 
 
297
    def test_sets_client_timeout(self):
 
298
        server = test_server.TestingSmartServer(('localhost', 0), None, None,
 
299
            root_client_path='/no-such-client/path')
 
300
        self.assertEqual(test_server._DEFAULT_TESTING_CLIENT_TIMEOUT,
 
301
                         server._client_timeout)
 
302
        sock = socket.socket()
 
303
        h = server._make_handler(sock)
 
304
        self.assertEqual(test_server._DEFAULT_TESTING_CLIENT_TIMEOUT,
 
305
                         h._client_timeout)
 
306
 
 
307
 
 
308
class FakeServer(object):
 
309
    """Minimal implementation to pass to TestingSmartConnectionHandler"""
 
310
    backing_transport = None
 
311
    root_client_path = '/'
 
312
 
 
313
 
 
314
class TestTestingSmartConnectionHandler(tests.TestCase):
 
315
 
 
316
    def test_connection_timeout_suppressed(self):
 
317
        self.overrideAttr(test_server, '_DEFAULT_TESTING_CLIENT_TIMEOUT', 0.01)
 
318
        s = FakeServer()
 
319
        server_sock, client_sock = portable_socket_pair()
 
320
        # This should timeout quickly, but not generate an exception.
 
321
        handler = test_server.TestingSmartConnectionHandler(server_sock,
 
322
            server_sock.getpeername(), s)
 
323
 
 
324
    def test_connection_shutdown_while_serving_no_error(self):
 
325
        s = FakeServer()
 
326
        server_sock, client_sock = portable_socket_pair()
 
327
        class ShutdownConnectionHandler(
 
328
            test_server.TestingSmartConnectionHandler):
 
329
 
 
330
            def _build_protocol(self):
 
331
                self.finished = True
 
332
                return super(ShutdownConnectionHandler, self)._build_protocol()
 
333
        # This should trigger shutdown after the entering _build_protocol, and
 
334
        # we should exit cleanly, without raising an exception.
 
335
        handler = ShutdownConnectionHandler(server_sock,
 
336
            server_sock.getpeername(), s)