Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 1 | """ |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 2 | Test suite for socketserver. |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 3 | """ |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 4 | |
Christian Heimes | 70e7ea2 | 2008-02-28 20:02:27 +0000 | [diff] [blame] | 5 | import contextlib |
Martin Panter | 34eeed4 | 2016-06-29 10:12:22 +0000 | [diff] [blame] | 6 | import io |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 7 | import os |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 8 | import select |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 9 | import signal |
| 10 | import socket |
| 11 | import tempfile |
Antoine Pitrou | a6a4dc8 | 2017-09-07 18:56:24 +0200 | [diff] [blame] | 12 | import threading |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 13 | import unittest |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 14 | import socketserver |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 15 | |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 16 | import test.support |
Antoine Pitrou | c00d4b4 | 2009-10-27 21:32:38 +0000 | [diff] [blame] | 17 | from test.support import reap_children, reap_threads, verbose |
Antoine Pitrou | a6a4dc8 | 2017-09-07 18:56:24 +0200 | [diff] [blame] | 18 | |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 19 | |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 20 | test.support.requires("network") |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 21 | |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 22 | TEST_STR = b"hello world\n" |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 23 | HOST = test.support.HOST |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 24 | |
| 25 | HAVE_UNIX_SOCKETS = hasattr(socket, "AF_UNIX") |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 26 | requires_unix_sockets = unittest.skipUnless(HAVE_UNIX_SOCKETS, |
| 27 | 'requires Unix sockets') |
Jesus Cea | f1af705 | 2012-10-05 02:48:46 +0200 | [diff] [blame] | 28 | HAVE_FORKING = hasattr(os, "fork") |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 29 | requires_forking = unittest.skipUnless(HAVE_FORKING, 'requires forking') |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 30 | |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 31 | def signal_alarm(n): |
| 32 | """Call signal.alarm when it exists (i.e. not on Windows).""" |
| 33 | if hasattr(signal, 'alarm'): |
| 34 | signal.alarm(n) |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 35 | |
Antoine Pitrou | f18d6f3 | 2012-04-09 01:16:47 +0200 | [diff] [blame] | 36 | # Remember real select() to avoid interferences with mocking |
| 37 | _real_select = select.select |
| 38 | |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 39 | def receive(sock, n, timeout=20): |
Antoine Pitrou | f18d6f3 | 2012-04-09 01:16:47 +0200 | [diff] [blame] | 40 | r, w, x = _real_select([sock], [], [], timeout) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 41 | if sock in r: |
| 42 | return sock.recv(n) |
| 43 | else: |
| 44 | raise RuntimeError("timed out on %r" % (sock,)) |
| 45 | |
Gregory P. Smith ext:(%20%5BGoogle%20Inc.%5D) | a945969 | 2016-06-03 05:26:14 +0000 | [diff] [blame] | 46 | if HAVE_UNIX_SOCKETS and HAVE_FORKING: |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 47 | class ForkingUnixStreamServer(socketserver.ForkingMixIn, |
| 48 | socketserver.UnixStreamServer): |
Christian Heimes | 15ebc88 | 2008-02-04 18:48:49 +0000 | [diff] [blame] | 49 | pass |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 50 | |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 51 | class ForkingUnixDatagramServer(socketserver.ForkingMixIn, |
| 52 | socketserver.UnixDatagramServer): |
Christian Heimes | 15ebc88 | 2008-02-04 18:48:49 +0000 | [diff] [blame] | 53 | pass |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 54 | |
| 55 | |
Christian Heimes | 70e7ea2 | 2008-02-28 20:02:27 +0000 | [diff] [blame] | 56 | @contextlib.contextmanager |
| 57 | def simple_subprocess(testcase): |
Martin Panter | d9108d1 | 2016-02-21 08:49:56 +0000 | [diff] [blame] | 58 | """Tests that a custom child process is not waited on (Issue 1540386)""" |
Christian Heimes | 70e7ea2 | 2008-02-28 20:02:27 +0000 | [diff] [blame] | 59 | pid = os.fork() |
| 60 | if pid == 0: |
Andrew Svetlov | 737fb89 | 2012-12-18 21:14:22 +0200 | [diff] [blame] | 61 | # Don't raise an exception; it would be caught by the test harness. |
Christian Heimes | 70e7ea2 | 2008-02-28 20:02:27 +0000 | [diff] [blame] | 62 | os._exit(72) |
xdegaye | 9001d1f | 2017-11-18 18:10:53 +0100 | [diff] [blame] | 63 | try: |
| 64 | yield None |
| 65 | except: |
| 66 | raise |
| 67 | finally: |
| 68 | pid2, status = os.waitpid(pid, 0) |
| 69 | testcase.assertEqual(pid2, pid) |
| 70 | testcase.assertEqual(72 << 8, status) |
Christian Heimes | 70e7ea2 | 2008-02-28 20:02:27 +0000 | [diff] [blame] | 71 | |
| 72 | |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 73 | class SocketServerTest(unittest.TestCase): |
| 74 | """Test all socket servers.""" |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 75 | |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 76 | def setUp(self): |
Victor Stinner | 5702ae6 | 2011-07-14 14:53:24 +0200 | [diff] [blame] | 77 | signal_alarm(60) # Kill deadlocks after 60 seconds. |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 78 | self.port_seed = 0 |
| 79 | self.test_files = [] |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 80 | |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 81 | def tearDown(self): |
Christian Heimes | fe337bf | 2008-03-23 21:54:12 +0000 | [diff] [blame] | 82 | signal_alarm(0) # Didn't deadlock. |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 83 | reap_children() |
Thomas Wouters | 00ee7ba | 2006-08-21 19:07:27 +0000 | [diff] [blame] | 84 | |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 85 | for fn in self.test_files: |
| 86 | try: |
| 87 | os.remove(fn) |
Andrew Svetlov | ad28c7f | 2012-12-18 22:02:39 +0200 | [diff] [blame] | 88 | except OSError: |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 89 | pass |
| 90 | self.test_files[:] = [] |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 91 | |
| 92 | def pickaddr(self, proto): |
| 93 | if proto == socket.AF_INET: |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 94 | return (HOST, 0) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 95 | else: |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 96 | # XXX: We need a way to tell AF_UNIX to pick its own name |
| 97 | # like AF_INET provides port==0. |
| 98 | dir = None |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 99 | fn = tempfile.mktemp(prefix='unix_socket.', dir=dir) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 100 | self.test_files.append(fn) |
| 101 | return fn |
| 102 | |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 103 | def make_server(self, addr, svrcls, hdlrbase): |
| 104 | class MyServer(svrcls): |
| 105 | def handle_error(self, request, client_address): |
| 106 | self.close_request(request) |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 107 | raise |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 108 | |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 109 | class MyHandler(hdlrbase): |
| 110 | def handle(self): |
| 111 | line = self.rfile.readline() |
| 112 | self.wfile.write(line) |
| 113 | |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 114 | if verbose: print("creating server") |
xdegaye | 9001d1f | 2017-11-18 18:10:53 +0100 | [diff] [blame] | 115 | try: |
| 116 | server = MyServer(addr, MyHandler) |
| 117 | except PermissionError as e: |
| 118 | # Issue 29184: cannot bind() a Unix socket on Android. |
| 119 | self.skipTest('Cannot create server (%s, %s): %s' % |
| 120 | (svrcls, addr, e)) |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 121 | self.assertEqual(server.server_address, server.socket.getsockname()) |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 122 | return server |
| 123 | |
Antoine Pitrou | c00d4b4 | 2009-10-27 21:32:38 +0000 | [diff] [blame] | 124 | @reap_threads |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 125 | def run_server(self, svrcls, hdlrbase, testfunc): |
| 126 | server = self.make_server(self.pickaddr(svrcls.address_family), |
| 127 | svrcls, hdlrbase) |
| 128 | # We had the OS pick a port, so pull the real address out of |
| 129 | # the server. |
| 130 | addr = server.server_address |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 131 | if verbose: |
| 132 | print("ADDR =", addr) |
| 133 | print("CLASS =", svrcls) |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 134 | |
| 135 | t = threading.Thread( |
| 136 | name='%s serving' % svrcls, |
| 137 | target=server.serve_forever, |
| 138 | # Short poll interval to make the test finish quickly. |
| 139 | # Time between requests is short enough that we won't wake |
| 140 | # up spuriously too many times. |
| 141 | kwargs={'poll_interval':0.01}) |
Benjamin Peterson | 7275370 | 2008-08-18 18:09:21 +0000 | [diff] [blame] | 142 | t.daemon = True # In case this function raises. |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 143 | t.start() |
| 144 | if verbose: print("server running") |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 145 | for i in range(3): |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 146 | if verbose: print("test client", i) |
| 147 | testfunc(svrcls.address_family, addr) |
| 148 | if verbose: print("waiting for server") |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 149 | server.shutdown() |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 150 | t.join() |
Victor Stinner | 109761b | 2011-01-03 14:30:39 +0000 | [diff] [blame] | 151 | server.server_close() |
Robert Collins | 1ee9283 | 2015-07-29 12:52:40 +1200 | [diff] [blame] | 152 | self.assertEqual(-1, server.socket.fileno()) |
Victor Stinner | aa8ec34 | 2017-08-10 15:28:16 +0200 | [diff] [blame] | 153 | if HAVE_FORKING and isinstance(server, socketserver.ForkingMixIn): |
| 154 | # bpo-31151: Check that ForkingMixIn.server_close() waits until |
| 155 | # all children completed |
| 156 | self.assertFalse(server.active_children) |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 157 | if verbose: print("done") |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 158 | |
| 159 | def stream_examine(self, proto, addr): |
Serhiy Storchaka | 5b10b98 | 2019-03-05 10:06:26 +0200 | [diff] [blame] | 160 | with socket.socket(proto, socket.SOCK_STREAM) as s: |
| 161 | s.connect(addr) |
| 162 | s.sendall(TEST_STR) |
| 163 | buf = data = receive(s, 100) |
| 164 | while data and b'\n' not in buf: |
| 165 | data = receive(s, 100) |
| 166 | buf += data |
| 167 | self.assertEqual(buf, TEST_STR) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 168 | |
| 169 | def dgram_examine(self, proto, addr): |
Serhiy Storchaka | 5b10b98 | 2019-03-05 10:06:26 +0200 | [diff] [blame] | 170 | with socket.socket(proto, socket.SOCK_DGRAM) as s: |
| 171 | if HAVE_UNIX_SOCKETS and proto == socket.AF_UNIX: |
| 172 | s.bind(self.pickaddr(proto)) |
| 173 | s.sendto(TEST_STR, addr) |
| 174 | buf = data = receive(s, 100) |
| 175 | while data and b'\n' not in buf: |
| 176 | data = receive(s, 100) |
| 177 | buf += data |
| 178 | self.assertEqual(buf, TEST_STR) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 179 | |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 180 | def test_TCPServer(self): |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 181 | self.run_server(socketserver.TCPServer, |
| 182 | socketserver.StreamRequestHandler, |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 183 | self.stream_examine) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 184 | |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 185 | def test_ThreadingTCPServer(self): |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 186 | self.run_server(socketserver.ThreadingTCPServer, |
| 187 | socketserver.StreamRequestHandler, |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 188 | self.stream_examine) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 189 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 190 | @requires_forking |
| 191 | def test_ForkingTCPServer(self): |
| 192 | with simple_subprocess(self): |
| 193 | self.run_server(socketserver.ForkingTCPServer, |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 194 | socketserver.StreamRequestHandler, |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 195 | self.stream_examine) |
| 196 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 197 | @requires_unix_sockets |
| 198 | def test_UnixStreamServer(self): |
| 199 | self.run_server(socketserver.UnixStreamServer, |
| 200 | socketserver.StreamRequestHandler, |
| 201 | self.stream_examine) |
| 202 | |
| 203 | @requires_unix_sockets |
| 204 | def test_ThreadingUnixStreamServer(self): |
| 205 | self.run_server(socketserver.ThreadingUnixStreamServer, |
| 206 | socketserver.StreamRequestHandler, |
| 207 | self.stream_examine) |
| 208 | |
| 209 | @requires_unix_sockets |
| 210 | @requires_forking |
| 211 | def test_ForkingUnixStreamServer(self): |
| 212 | with simple_subprocess(self): |
| 213 | self.run_server(ForkingUnixStreamServer, |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 214 | socketserver.StreamRequestHandler, |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 215 | self.stream_examine) |
| 216 | |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 217 | def test_UDPServer(self): |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 218 | self.run_server(socketserver.UDPServer, |
| 219 | socketserver.DatagramRequestHandler, |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 220 | self.dgram_examine) |
| 221 | |
| 222 | def test_ThreadingUDPServer(self): |
Alexandre Vassalotti | ce26195 | 2008-05-12 02:31:37 +0000 | [diff] [blame] | 223 | self.run_server(socketserver.ThreadingUDPServer, |
| 224 | socketserver.DatagramRequestHandler, |
Christian Heimes | 9e7f1d2 | 2008-02-28 12:27:11 +0000 | [diff] [blame] | 225 | self.dgram_examine) |
| 226 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 227 | @requires_forking |
| 228 | def test_ForkingUDPServer(self): |
| 229 | with simple_subprocess(self): |
| 230 | self.run_server(socketserver.ForkingUDPServer, |
| 231 | socketserver.DatagramRequestHandler, |
| 232 | self.dgram_examine) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 233 | |
Martin Panter | 1827eff | 2016-02-24 05:12:59 +0000 | [diff] [blame] | 234 | @requires_unix_sockets |
| 235 | def test_UnixDatagramServer(self): |
| 236 | self.run_server(socketserver.UnixDatagramServer, |
| 237 | socketserver.DatagramRequestHandler, |
| 238 | self.dgram_examine) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 239 | |
Martin Panter | 1827eff | 2016-02-24 05:12:59 +0000 | [diff] [blame] | 240 | @requires_unix_sockets |
| 241 | def test_ThreadingUnixDatagramServer(self): |
| 242 | self.run_server(socketserver.ThreadingUnixDatagramServer, |
| 243 | socketserver.DatagramRequestHandler, |
| 244 | self.dgram_examine) |
| 245 | |
| 246 | @requires_unix_sockets |
| 247 | @requires_forking |
| 248 | def test_ForkingUnixDatagramServer(self): |
| 249 | self.run_server(ForkingUnixDatagramServer, |
| 250 | socketserver.DatagramRequestHandler, |
| 251 | self.dgram_examine) |
Christian Heimes | 292d351 | 2008-02-03 16:51:08 +0000 | [diff] [blame] | 252 | |
Antoine Pitrou | 3bcba8e | 2010-04-25 22:01:43 +0000 | [diff] [blame] | 253 | @reap_threads |
| 254 | def test_shutdown(self): |
| 255 | # Issue #2302: shutdown() should always succeed in making an |
| 256 | # other thread leave serve_forever(). |
| 257 | class MyServer(socketserver.TCPServer): |
| 258 | pass |
| 259 | |
| 260 | class MyHandler(socketserver.StreamRequestHandler): |
| 261 | pass |
| 262 | |
| 263 | threads = [] |
| 264 | for i in range(20): |
| 265 | s = MyServer((HOST, 0), MyHandler) |
| 266 | t = threading.Thread( |
| 267 | name='MyServer serving', |
| 268 | target=s.serve_forever, |
| 269 | kwargs={'poll_interval':0.01}) |
| 270 | t.daemon = True # In case this function raises. |
| 271 | threads.append((t, s)) |
| 272 | for t, s in threads: |
| 273 | t.start() |
| 274 | s.shutdown() |
| 275 | for t, s in threads: |
| 276 | t.join() |
Victor Stinner | 109761b | 2011-01-03 14:30:39 +0000 | [diff] [blame] | 277 | s.server_close() |
Antoine Pitrou | 3bcba8e | 2010-04-25 22:01:43 +0000 | [diff] [blame] | 278 | |
Charles-François Natali | 0f4f048 | 2014-10-13 19:19:26 +0100 | [diff] [blame] | 279 | def test_tcpserver_bind_leak(self): |
| 280 | # Issue #22435: the server socket wouldn't be closed if bind()/listen() |
| 281 | # failed. |
| 282 | # Create many servers for which bind() will fail, to see if this result |
| 283 | # in FD exhaustion. |
| 284 | for i in range(1024): |
| 285 | with self.assertRaises(OverflowError): |
| 286 | socketserver.TCPServer((HOST, -1), |
| 287 | socketserver.StreamRequestHandler) |
| 288 | |
Martin Panter | 0cab9c1 | 2016-04-13 00:36:52 +0000 | [diff] [blame] | 289 | def test_context_manager(self): |
| 290 | with socketserver.TCPServer((HOST, 0), |
| 291 | socketserver.StreamRequestHandler) as server: |
| 292 | pass |
| 293 | self.assertEqual(-1, server.socket.fileno()) |
| 294 | |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 295 | |
Martin Panter | d9108d1 | 2016-02-21 08:49:56 +0000 | [diff] [blame] | 296 | class ErrorHandlerTest(unittest.TestCase): |
| 297 | """Test that the servers pass normal exceptions from the handler to |
| 298 | handle_error(), and that exiting exceptions like SystemExit and |
| 299 | KeyboardInterrupt are not passed.""" |
| 300 | |
| 301 | def tearDown(self): |
| 302 | test.support.unlink(test.support.TESTFN) |
| 303 | |
| 304 | def test_sync_handled(self): |
| 305 | BaseErrorTestServer(ValueError) |
| 306 | self.check_result(handled=True) |
| 307 | |
| 308 | def test_sync_not_handled(self): |
| 309 | with self.assertRaises(SystemExit): |
| 310 | BaseErrorTestServer(SystemExit) |
| 311 | self.check_result(handled=False) |
| 312 | |
Martin Panter | d9108d1 | 2016-02-21 08:49:56 +0000 | [diff] [blame] | 313 | def test_threading_handled(self): |
| 314 | ThreadingErrorTestServer(ValueError) |
| 315 | self.check_result(handled=True) |
| 316 | |
Martin Panter | d9108d1 | 2016-02-21 08:49:56 +0000 | [diff] [blame] | 317 | def test_threading_not_handled(self): |
| 318 | ThreadingErrorTestServer(SystemExit) |
| 319 | self.check_result(handled=False) |
| 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(test.support.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(test.support.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(test.support.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 | |
Gregory P. Smith ext:(%20%5BGoogle%20Inc.%5D) | a945969 | 2016-06-03 05:26:14 +0000 | [diff] [blame] | 378 | if HAVE_FORKING: |
| 379 | class ForkingErrorTestServer(socketserver.ForkingMixIn, BaseErrorTestServer): |
Victor Stinner | aa8ec34 | 2017-08-10 15:28:16 +0200 | [diff] [blame] | 380 | pass |
Martin Panter | d9108d1 | 2016-02-21 08:49:56 +0000 | [diff] [blame] | 381 | |
| 382 | |
Martin Panter | 34eeed4 | 2016-06-29 10:12:22 +0000 | [diff] [blame] | 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 | |
Martin Panter | 34eeed4 | 2016-06-29 10:12:22 +0000 | [diff] [blame] | 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() |
Serhiy Storchaka | 5f1a518 | 2016-09-11 14:41:02 +0300 | [diff] [blame] | 411 | big_chunk = b'\0' * test.support.SOCK_MAX_SIZE |
Martin Panter | 34eeed4 | 2016-06-29 10:12:22 +0000 | [diff] [blame] | 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 | |
Berker Peksag | 3265344 | 2015-02-03 11:55:09 +0200 | [diff] [blame] | 460 | class MiscTestCase(unittest.TestCase): |
Tim Peters | a9f6f22 | 2001-09-17 23:56:20 +0000 | [diff] [blame] | 461 | |
Berker Peksag | 3265344 | 2015-02-03 11:55:09 +0200 | [diff] [blame] | 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 | |
Martin Panter | 4bf4274 | 2016-02-19 02:16:42 +0000 | [diff] [blame] | 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 | |
Guido van Rossum | 39f1b36 | 2001-07-10 11:52:38 +0000 | [diff] [blame] | 493 | |
Tim Peters | a9f6f22 | 2001-09-17 23:56:20 +0000 | [diff] [blame] | 494 | if __name__ == "__main__": |
Berker Peksag | 3265344 | 2015-02-03 11:55:09 +0200 | [diff] [blame] | 495 | unittest.main() |