Debian Codegraph @

Lib/test/test_socketserver.py

raw
1 """
2 Test suite for socketserver.
3 """
4
5 import contextlib
6 import io
7 import os
8 import select
9 import signal
10 import socket
11 import threading
12 import unittest
13 import socketserver
14
15 import test.support
16 from test.support import reap_children, verbose
17 from test.support import os_helper
18 from test.support import socket_helper
19 from test.support import threading_helper
20
21
22 test.support.requires("network")
23 test.support.requires_working_socket(module=True)
24
25
26 TEST_STR = b"hello world\n"
27 HOST = socket_helper.HOST
28
29 HAVE_UNIX_SOCKETS = hasattr(socket, "AF_UNIX")
30 requires_unix_sockets = unittest.skipUnless(HAVE_UNIX_SOCKETS,
31 'requires Unix sockets')
32 HAVE_FORKING = test.support.has_fork_support
33 requires_forking = unittest.skipUnless(HAVE_FORKING, 'requires forking')
34
35 # Remember real select() to avoid interferences with mocking
36 _real_select = select.select
37
38 def receive(sock, n, timeout=test.support.SHORT_TIMEOUT):
39 r, w, x = _real_select([sock], [], [], timeout)
40 if sock in r:
41 return sock.recv(n)
42 else:
43 raise RuntimeError("timed out on %r" % (sock,))
44
45
46 @test.support.requires_fork()
47 @contextlib.contextmanager
48 def simple_subprocess(testcase):
49 """Tests that a custom child process is not waited on (Issue 1540386)"""
50 pid = os.fork()
51 if pid == 0:
52 # Don't raise an exception; it would be caught by the test harness.
53 os._exit(72)
54 try:
55 yield None
56 except:
57 raise
58 finally:
59 test.support.wait_process(pid, exitcode=72)
60
61
62 class SocketServerTest(unittest.TestCase):
63 """Test all socket servers."""
64
65 def setUp(self):
66 self.port_seed = 0
67 self.test_files = []
68
69 def tearDown(self):
70 reap_children()
71
72 for fn in self.test_files:
73 try:
74 os.remove(fn)
75 except OSError:
76 pass
77 self.test_files[:] = []
78
79 def pickaddr(self, proto):
80 if proto == socket.AF_INET:
81 return (HOST, 0)
82 else:
83 # XXX: We need a way to tell AF_UNIX to pick its own name
84 # like AF_INET provides port==0.
85 fn = socket_helper.create_unix_domain_name()
86 self.test_files.append(fn)
87 return fn
88
89 def make_server(self, addr, svrcls, hdlrbase):
90 class MyServer(svrcls):
91 def handle_error(self, request, client_address):
92 self.close_request(request)
93 raise
94
95 class MyHandler(hdlrbase):
96 def handle(self):
97 line = self.rfile.readline()
98 self.wfile.write(line)
99
100 if verbose: print("creating server")
101 try:
102 server = MyServer(addr, MyHandler)
103 except PermissionError as e:
104 # Issue 29184: cannot bind() a Unix socket on Android.
105 self.skipTest('Cannot create server (%s, %s): %s' %
106 (svrcls, addr, e))
107 self.assertEqual(server.server_address, server.socket.getsockname())
108 return server
109
110 @threading_helper.reap_threads
111 def run_server(self, svrcls, hdlrbase, testfunc):
112 server = self.make_server(self.pickaddr(svrcls.address_family),
113 svrcls, hdlrbase)
114 # We had the OS pick a port, so pull the real address out of
115 # the server.
116 addr = server.server_address
117 if verbose:
118 print("ADDR =", addr)
119 print("CLASS =", svrcls)
120
121 t = threading.Thread(
122 name='%s serving' % svrcls,
123 target=server.serve_forever,
124 # Short poll interval to make the test finish quickly.
125 # Time between requests is short enough that we won't wake
126 # up spuriously too many times.
127 kwargs={'poll_interval':0.01})
128 t.daemon = True # In case this function raises.
129 t.start()
130 if verbose: print("server running")
131 for i in range(3):
132 if verbose: print("test client", i)
133 testfunc(svrcls.address_family, addr)
134 if verbose: print("waiting for server")
135 server.shutdown()
136 t.join()
137 server.server_close()
138 self.assertEqual(-1, server.socket.fileno())
139 if HAVE_FORKING and isinstance(server, socketserver.ForkingMixIn):
140 # bpo-31151: Check that ForkingMixIn.server_close() waits until
141 # all children completed
142 self.assertFalse(server.active_children)
143 if verbose: print("done")
144
145 def stream_examine(self, proto, addr):
146 with socket.socket(proto, socket.SOCK_STREAM) as s:
147 s.connect(addr)
148 s.sendall(TEST_STR)
149 buf = data = receive(s, 100)
150 while data and b'\n' not in buf:
151 data = receive(s, 100)
152 buf += data
153 self.assertEqual(buf, TEST_STR)
154
155 def dgram_examine(self, proto, addr):
156 with socket.socket(proto, socket.SOCK_DGRAM) as s:
157 if HAVE_UNIX_SOCKETS and proto == socket.AF_UNIX:
158 s.bind(self.pickaddr(proto))
159 s.sendto(TEST_STR, addr)
160 buf = data = receive(s, 100)
161 while data and b'\n' not in buf:
162 data = receive(s, 100)
163 buf += data
164 self.assertEqual(buf, TEST_STR)
165
166 def test_TCPServer(self):
167 self.run_server(socketserver.TCPServer,
168 socketserver.StreamRequestHandler,
169 self.stream_examine)
170
171 def test_ThreadingTCPServer(self):
172 self.run_server(socketserver.ThreadingTCPServer,
173 socketserver.StreamRequestHandler,
174 self.stream_examine)
175
176 @requires_forking
177 def test_ForkingTCPServer(self):
178 with simple_subprocess(self):
179 self.run_server(socketserver.ForkingTCPServer,
180 socketserver.StreamRequestHandler,
181 self.stream_examine)
182
183 @requires_unix_sockets
184 def test_UnixStreamServer(self):
185 self.run_server(socketserver.UnixStreamServer,
186 socketserver.StreamRequestHandler,
187 self.stream_examine)
188
189 @requires_unix_sockets
190 def test_ThreadingUnixStreamServer(self):
191 self.run_server(socketserver.ThreadingUnixStreamServer,
192 socketserver.StreamRequestHandler,
193 self.stream_examine)
194
195 @requires_unix_sockets
196 @requires_forking
197 def test_ForkingUnixStreamServer(self):
198 with simple_subprocess(self):
199 self.run_server(socketserver.ForkingUnixStreamServer,
200 socketserver.StreamRequestHandler,
201 self.stream_examine)
202
203 def test_UDPServer(self):
204 self.run_server(socketserver.UDPServer,
205 socketserver.DatagramRequestHandler,
206 self.dgram_examine)
207
208 def test_ThreadingUDPServer(self):
209 self.run_server(socketserver.ThreadingUDPServer,
210 socketserver.DatagramRequestHandler,
211 self.dgram_examine)
212
213 @requires_forking
214 def test_ForkingUDPServer(self):
215 with simple_subprocess(self):
216 self.run_server(socketserver.ForkingUDPServer,
217 socketserver.DatagramRequestHandler,
218 self.dgram_examine)
219
220 @requires_unix_sockets
221 @unittest.skipIf(test.support.is_apple_mobile and test.support.on_github_actions,
222 "gh-140702: Test fails regularly on iOS simulator on GitHub Actions")
223 def test_UnixDatagramServer(self):
224 self.run_server(socketserver.UnixDatagramServer,
225 socketserver.DatagramRequestHandler,
226 self.dgram_examine)
227
228 @requires_unix_sockets
229 @unittest.skipIf(test.support.is_apple_mobile and test.support.on_github_actions,
230 "gh-140702: Test fails regularly on iOS simulator on GitHub Actions")
231 def test_ThreadingUnixDatagramServer(self):
232 self.run_server(socketserver.ThreadingUnixDatagramServer,
233 socketserver.DatagramRequestHandler,
234 self.dgram_examine)
235
236 @requires_unix_sockets
237 @requires_forking
238 def test_ForkingUnixDatagramServer(self):
239 self.run_server(socketserver.ForkingUnixDatagramServer,
240 socketserver.DatagramRequestHandler,
241 self.dgram_examine)
242
243 @threading_helper.reap_threads
244 def test_shutdown(self):
245 # Issue #2302: shutdown() should always succeed in making an
246 # other thread leave serve_forever().
247 class MyServer(socketserver.TCPServer):
248 pass
249
250 class MyHandler(socketserver.StreamRequestHandler):
251 pass
252
253 threads = []
254 for i in range(20):
255 s = MyServer((HOST, 0), MyHandler)
256 t = threading.Thread(
257 name='MyServer serving',
258 target=s.serve_forever,
259 kwargs={'poll_interval':0.01})
260 t.daemon = True # In case this function raises.
261 threads.append((t, s))
262 for t, s in threads:
263 t.start()
264 s.shutdown()
265 for t, s in threads:
266 t.join()
267 s.server_close()
268
269 def test_close_immediately(self):
270 class MyServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
271 pass
272
273 server = MyServer((HOST, 0), lambda: None)
274 server.server_close()
275
276 def test_tcpserver_bind_leak(self):
277 # Issue #22435: the server socket wouldn't be closed if bind()/listen()
278 # failed.
279 # Create many servers for which bind() will fail, to see if this result
280 # in FD exhaustion.
281 for i in range(1024):
282 with self.assertRaises(OverflowError):
283 socketserver.TCPServer((HOST, -1),
284 socketserver.StreamRequestHandler)
285
286 def test_context_manager(self):
287 with socketserver.TCPServer((HOST, 0),
288 socketserver.StreamRequestHandler) as server:
289 pass
290 self.assertEqual(-1, server.socket.fileno())
291
292
293 class ErrorHandlerTest(unittest.TestCase):
294 """Test that the servers pass normal exceptions from the handler to
295 handle_error(), and that exiting exceptions like SystemExit and
296 KeyboardInterrupt are not passed."""
297
298 def tearDown(self):
299 os_helper.unlink(os_helper.TESTFN)
300
301 def test_sync_handled(self):
302 BaseErrorTestServer(ValueError)
303 self.check_result(handled=True)
304
305 def test_sync_not_handled(self):
306 with self.assertRaises(SystemExit):
307 BaseErrorTestServer(SystemExit)
308 self.check_result(handled=False)
309
310 def test_threading_handled(self):
311 ThreadingErrorTestServer(ValueError)
312 self.check_result(handled=True)
313
314 def test_threading_not_handled(self):
315 with threading_helper.catch_threading_exception() as cm:
316 ThreadingErrorTestServer(SystemExit)
317 self.check_result(handled=False)
318
319 self.assertIs(cm.exc_type, SystemExit)
320
321 @requires_forking
322 def test_forking_handled(self):
323 ForkingErrorTestServer(ValueError)
324 self.check_result(handled=True)
325
326 @requires_forking
327 def test_forking_not_handled(self):
328 ForkingErrorTestServer(SystemExit)
329 self.check_result(handled=False)
330
331 def check_result(self, handled):
332 with open(os_helper.TESTFN) as log:
333 expected = 'Handler called\n' + 'Error handled\n' * handled
334 self.assertEqual(log.read(), expected)
335
336
337 class BaseErrorTestServer(socketserver.TCPServer):
338 def __init__(self, exception):
339 self.exception = exception
340 super().__init__((HOST, 0), BadHandler)
341 with socket.create_connection(self.server_address):
342 pass
343 try:
344 self.handle_request()
345 finally:
346 self.server_close()
347 self.wait_done()
348
349 def handle_error(self, request, client_address):
350 with open(os_helper.TESTFN, 'a') as log:
351 log.write('Error handled\n')
352
353 def wait_done(self):
354 pass
355
356
357 class BadHandler(socketserver.BaseRequestHandler):
358 def handle(self):
359 with open(os_helper.TESTFN, 'a') as log:
360 log.write('Handler called\n')
361 raise self.server.exception('Test error')
362
363
364 class ThreadingErrorTestServer(socketserver.ThreadingMixIn,
365 BaseErrorTestServer):
366 def __init__(self, *pos, **kw):
367 self.done = threading.Event()
368 super().__init__(*pos, **kw)
369
370 def shutdown_request(self, *pos, **kw):
371 super().shutdown_request(*pos, **kw)
372 self.done.set()
373
374 def wait_done(self):
375 self.done.wait()
376
377
378 if HAVE_FORKING:
379 class ForkingErrorTestServer(socketserver.ForkingMixIn, BaseErrorTestServer):
380 pass
381
382
383 class SocketWriterTest(unittest.TestCase):
384 def test_basics(self):
385 class Handler(socketserver.StreamRequestHandler):
386 def handle(self):
387 self.server.wfile = self.wfile
388 self.server.wfile_fileno = self.wfile.fileno()
389 self.server.request_fileno = self.request.fileno()
390
391 server = socketserver.TCPServer((HOST, 0), Handler)
392 self.addCleanup(server.server_close)
393 s = socket.socket(
394 server.address_family, socket.SOCK_STREAM, socket.IPPROTO_TCP)
395 with s:
396 s.connect(server.server_address)
397 server.handle_request()
398 self.assertIsInstance(server.wfile, io.BufferedIOBase)
399 self.assertEqual(server.wfile_fileno, server.request_fileno)
400
401 def test_write(self):
402 # Test that wfile.write() sends data immediately, and that it does
403 # not truncate sends when interrupted by a Unix signal
404 pthread_kill = test.support.get_attribute(signal, 'pthread_kill')
405
406 class Handler(socketserver.StreamRequestHandler):
407 def handle(self):
408 self.server.sent1 = self.wfile.write(b'write data\n')
409 # Should be sent immediately, without requiring flush()
410 self.server.received = self.rfile.readline()
411 big_chunk = b'\0' * test.support.SOCK_MAX_SIZE
412 self.server.sent2 = self.wfile.write(big_chunk)
413
414 server = socketserver.TCPServer((HOST, 0), Handler)
415 self.addCleanup(server.server_close)
416 interrupted = threading.Event()
417
418 def signal_handler(signum, frame):
419 interrupted.set()
420
421 original = signal.signal(signal.SIGUSR1, signal_handler)
422 self.addCleanup(signal.signal, signal.SIGUSR1, original)
423 response1 = None
424 received2 = None
425 main_thread = threading.get_ident()
426
427 def run_client():
428 s = socket.socket(server.address_family, socket.SOCK_STREAM,
429 socket.IPPROTO_TCP)
430 with s, s.makefile('rb') as reader:
431 s.connect(server.server_address)
432 nonlocal response1
433 response1 = reader.readline()
434 s.sendall(b'client response\n')
435
436 reader.read(100)
437 # The main thread should now be blocking in a send() syscall.
438 # But in theory, it could get interrupted by other signals,
439 # and then retried. So keep sending the signal in a loop, in
440 # case an earlier signal happens to be delivered at an
441 # inconvenient moment.
442 while True:
443 pthread_kill(main_thread, signal.SIGUSR1)
444 if interrupted.wait(timeout=float(1)):
445 break
446 nonlocal received2
447 received2 = len(reader.read())
448
449 background = threading.Thread(target=run_client)
450 background.start()
451 server.handle_request()
452 background.join()
453 self.assertEqual(server.sent1, len(response1))
454 self.assertEqual(response1, b'write data\n')
455 self.assertEqual(server.received, b'client response\n')
456 self.assertEqual(server.sent2, test.support.SOCK_MAX_SIZE)
457 self.assertEqual(received2, test.support.SOCK_MAX_SIZE - 100)
458
459
460 class MiscTestCase(unittest.TestCase):
461
462 def test_all(self):
463 # objects defined in the module should be in __all__
464 expected = []
465 for name in dir(socketserver):
466 if not name.startswith('_'):
467 mod_object = getattr(socketserver, name)
468 if getattr(mod_object, '__module__', None) == 'socketserver':
469 expected.append(name)
470 self.assertCountEqual(socketserver.__all__, expected)
471
472 def test_shutdown_request_called_if_verify_request_false(self):
473 # Issue #26309: BaseServer should call shutdown_request even if
474 # verify_request is False
475
476 class MyServer(socketserver.TCPServer):
477 def verify_request(self, request, client_address):
478 return False
479
480 shutdown_called = 0
481 def shutdown_request(self, request):
482 self.shutdown_called += 1
483 socketserver.TCPServer.shutdown_request(self, request)
484
485 server = MyServer((HOST, 0), socketserver.StreamRequestHandler)
486 s = socket.socket(server.address_family, socket.SOCK_STREAM)
487 s.connect(server.server_address)
488 s.close()
489 server.handle_request()
490 self.assertEqual(server.shutdown_called, 1)
491 server.server_close()
492
493 def test_threads_reaped(self):
494 """
495 In #37193, users reported a memory leak
496 due to the saving of every request thread. Ensure that
497 not all threads are kept forever.
498 """
499 class MyServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
500 pass
501
502 server = MyServer((HOST, 0), socketserver.StreamRequestHandler)
503 for n in range(10):
504 with socket.create_connection(server.server_address):
505 server.handle_request()
506 self.assertLess(len(server._threads), 10)
507 server.server_close()
508
509
510 if __name__ == "__main__":
511 unittest.main()