Debian Codegraph @

Lib/test/test_asyncio/test_server.py

raw
1 import asyncio
2 import os
3 import socket
4 import time
5 import threading
6 import unittest
7
8 from test.support import socket_helper
9 from test.test_asyncio import utils as test_utils
10 from test.test_asyncio import functional as func_tests
11
12
13 def tearDownModule():
14 asyncio.events._set_event_loop_policy(None)
15
16
17 class BaseStartServer(func_tests.FunctionalTestCaseMixin):
18
19 def new_loop(self):
20 raise NotImplementedError
21
22 def test_start_server_1(self):
23 HELLO_MSG = b'1' * 1024 * 5 + b'\n'
24
25 def client(sock, addr):
26 for i in range(10):
27 time.sleep(0.2)
28 if srv.is_serving():
29 break
30 else:
31 raise RuntimeError
32
33 sock.settimeout(2)
34 sock.connect(addr)
35 sock.send(HELLO_MSG)
36 sock.recv_all(1)
37 sock.close()
38
39 async def serve(reader, writer):
40 await reader.readline()
41 main_task.cancel()
42 writer.write(b'1')
43 writer.close()
44 await writer.wait_closed()
45
46 async def main(srv):
47 async with srv:
48 await srv.serve_forever()
49
50 srv = self.loop.run_until_complete(asyncio.start_server(
51 serve, socket_helper.HOSTv4, 0, start_serving=False))
52
53 self.assertFalse(srv.is_serving())
54
55 main_task = self.loop.create_task(main(srv))
56
57 addr = srv.sockets[0].getsockname()
58 with self.assertRaises(asyncio.CancelledError):
59 with self.tcp_client(lambda sock: client(sock, addr)):
60 self.loop.run_until_complete(main_task)
61
62 self.assertEqual(srv.sockets, ())
63
64 self.assertIsNone(srv._sockets)
65 self.assertIsNone(srv._waiters)
66 self.assertFalse(srv.is_serving())
67
68 with self.assertRaisesRegex(RuntimeError, r'is closed'):
69 self.loop.run_until_complete(srv.serve_forever())
70
71
72 class SelectorStartServerTests(BaseStartServer, unittest.TestCase):
73
74 def new_loop(self):
75 return asyncio.SelectorEventLoop()
76
77 @socket_helper.skip_unless_bind_unix_socket
78 def test_start_unix_server_1(self):
79 HELLO_MSG = b'1' * 1024 * 5 + b'\n'
80 started = threading.Event()
81
82 def client(sock, addr):
83 sock.settimeout(2)
84 started.wait(5)
85 sock.connect(addr)
86 sock.send(HELLO_MSG)
87 sock.recv_all(1)
88 sock.close()
89
90 async def serve(reader, writer):
91 await reader.readline()
92 main_task.cancel()
93 writer.write(b'1')
94 writer.close()
95 await writer.wait_closed()
96
97 async def main(srv):
98 async with srv:
99 self.assertFalse(srv.is_serving())
100 await srv.start_serving()
101 self.assertTrue(srv.is_serving())
102 started.set()
103 await srv.serve_forever()
104
105 with test_utils.unix_socket_path() as addr:
106 srv = self.loop.run_until_complete(asyncio.start_unix_server(
107 serve, addr, start_serving=False))
108
109 main_task = self.loop.create_task(main(srv))
110
111 with self.assertRaises(asyncio.CancelledError):
112 with self.unix_client(lambda sock: client(sock, addr)):
113 self.loop.run_until_complete(main_task)
114
115 self.assertEqual(srv.sockets, ())
116
117 self.assertIsNone(srv._sockets)
118 self.assertIsNone(srv._waiters)
119 self.assertFalse(srv.is_serving())
120
121 with self.assertRaisesRegex(RuntimeError, r'is closed'):
122 self.loop.run_until_complete(srv.serve_forever())
123
124
125 class TestServer2(unittest.IsolatedAsyncioTestCase):
126
127 async def test_wait_closed_basic(self):
128 async def serve(rd, wr):
129 try:
130 await rd.read()
131 finally:
132 wr.close()
133 await wr.wait_closed()
134
135 srv = await asyncio.start_server(serve, socket_helper.HOSTv4, 0)
136 self.addCleanup(srv.close)
137
138 # active count = 0, not closed: should block
139 task1 = asyncio.create_task(srv.wait_closed())
140 await asyncio.sleep(0)
141 self.assertFalse(task1.done())
142
143 # active count != 0, not closed: should block
144 addr = srv.sockets[0].getsockname()
145 (rd, wr) = await asyncio.open_connection(addr[0], addr[1])
146 task2 = asyncio.create_task(srv.wait_closed())
147 await asyncio.sleep(0)
148 self.assertFalse(task1.done())
149 self.assertFalse(task2.done())
150
151 srv.close()
152 await asyncio.sleep(0)
153 # active count != 0, closed: should block
154 task3 = asyncio.create_task(srv.wait_closed())
155 await asyncio.sleep(0)
156 self.assertFalse(task1.done())
157 self.assertFalse(task2.done())
158 self.assertFalse(task3.done())
159
160 wr.close()
161 await wr.wait_closed()
162 # active count == 0, closed: should unblock
163 await task1
164 await task2
165 await task3
166 await srv.wait_closed() # Return immediately
167
168 async def test_wait_closed_race(self):
169 # Test a regression in 3.12.0, should be fixed in 3.12.1
170 async def serve(rd, wr):
171 try:
172 await rd.read()
173 finally:
174 wr.close()
175 await wr.wait_closed()
176
177 srv = await asyncio.start_server(serve, socket_helper.HOSTv4, 0)
178 self.addCleanup(srv.close)
179
180 task = asyncio.create_task(srv.wait_closed())
181 await asyncio.sleep(0)
182 self.assertFalse(task.done())
183 addr = srv.sockets[0].getsockname()
184 (rd, wr) = await asyncio.open_connection(addr[0], addr[1])
185 loop = asyncio.get_running_loop()
186 loop.call_soon(srv.close)
187 loop.call_soon(wr.close)
188 await srv.wait_closed()
189
190 async def test_close_clients(self):
191 async def serve(rd, wr):
192 try:
193 await rd.read()
194 finally:
195 wr.close()
196 await wr.wait_closed()
197
198 srv = await asyncio.start_server(serve, socket_helper.HOSTv4, 0)
199 self.addCleanup(srv.close)
200
201 addr = srv.sockets[0].getsockname()
202 (rd, wr) = await asyncio.open_connection(addr[0], addr[1])
203 self.addCleanup(wr.close)
204
205 task = asyncio.create_task(srv.wait_closed())
206 await asyncio.sleep(0)
207 self.assertFalse(task.done())
208
209 srv.close()
210 srv.close_clients()
211 await asyncio.sleep(0)
212 await asyncio.sleep(0)
213 self.assertTrue(task.done())
214
215 async def test_abort_clients(self):
216 async def serve(rd, wr):
217 fut.set_result((rd, wr))
218 await wr.wait_closed()
219
220 fut = asyncio.Future()
221 srv = await asyncio.start_server(serve, socket_helper.HOSTv4, 0)
222 self.addCleanup(srv.close)
223
224 addr = srv.sockets[0].getsockname()
225 (c_rd, c_wr) = await asyncio.open_connection(addr[0], addr[1], limit=4096)
226 self.addCleanup(c_wr.close)
227
228 (s_rd, s_wr) = await fut
229
230 # Limit the socket buffers so we can more reliably overfill them
231 s_sock = s_wr.get_extra_info('socket')
232 s_sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 65536)
233 c_sock = c_wr.get_extra_info('socket')
234 c_sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 65536)
235
236 # Get the reader in to a paused state by sending more than twice
237 # the configured limit
238 s_wr.write(b'a' * 4096)
239 s_wr.write(b'a' * 4096)
240 s_wr.write(b'a' * 4096)
241 while c_wr.transport.is_reading():
242 await asyncio.sleep(0)
243
244 # Get the writer in a waiting state by sending data until the
245 # kernel stops accepting more data in the send buffer.
246 # gh-122136: getsockopt() does not reliably report the buffer size
247 # available for message content.
248 # We loop until we start filling up the asyncio buffer.
249 # To avoid an infinite loop we cap at 10 times the expected value
250 c_bufsize = c_sock.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)
251 s_bufsize = s_sock.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)
252 for i in range(10):
253 s_wr.write(b'a' * c_bufsize)
254 s_wr.write(b'a' * s_bufsize)
255 if s_wr.transport.get_write_buffer_size() > 0:
256 break
257 self.assertNotEqual(s_wr.transport.get_write_buffer_size(), 0)
258
259 task = asyncio.create_task(srv.wait_closed())
260 await asyncio.sleep(0)
261 self.assertFalse(task.done())
262
263 srv.close()
264 srv.abort_clients()
265 await asyncio.sleep(0)
266 await asyncio.sleep(0)
267 self.assertTrue(task.done())
268
269
270 # Test the various corner cases of Unix server socket removal
271 class UnixServerCleanupTests(unittest.IsolatedAsyncioTestCase):
272 @socket_helper.skip_unless_bind_unix_socket
273 async def test_unix_server_addr_cleanup(self):
274 # Default scenario
275 with test_utils.unix_socket_path() as addr:
276 async def serve(*args):
277 pass
278
279 srv = await asyncio.start_unix_server(serve, addr)
280
281 srv.close()
282 self.assertFalse(os.path.exists(addr))
283
284 @socket_helper.skip_unless_bind_unix_socket
285 async def test_unix_server_sock_cleanup(self):
286 # Using already bound socket
287 with test_utils.unix_socket_path() as addr:
288 async def serve(*args):
289 pass
290
291 with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
292 sock.bind(addr)
293
294 srv = await asyncio.start_unix_server(serve, sock=sock)
295
296 srv.close()
297 self.assertFalse(os.path.exists(addr))
298
299 @socket_helper.skip_unless_bind_unix_socket
300 async def test_unix_server_cleanup_gone(self):
301 # Someone else has already cleaned up the socket
302 with test_utils.unix_socket_path() as addr:
303 async def serve(*args):
304 pass
305
306 with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
307 sock.bind(addr)
308
309 srv = await asyncio.start_unix_server(serve, sock=sock)
310
311 os.unlink(addr)
312
313 srv.close()
314
315 @socket_helper.skip_unless_bind_unix_socket
316 async def test_unix_server_cleanup_replaced(self):
317 # Someone else has replaced the socket with their own
318 with test_utils.unix_socket_path() as addr:
319 async def serve(*args):
320 pass
321
322 srv = await asyncio.start_unix_server(serve, addr)
323
324 os.unlink(addr)
325 with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
326 sock.bind(addr)
327
328 srv.close()
329 self.assertTrue(os.path.exists(addr))
330
331 @socket_helper.skip_unless_bind_unix_socket
332 async def test_unix_server_cleanup_prevented(self):
333 # Automatic cleanup explicitly disabled
334 with test_utils.unix_socket_path() as addr:
335 async def serve(*args):
336 pass
337
338 srv = await asyncio.start_unix_server(serve, addr, cleanup_socket=False)
339
340 srv.close()
341 self.assertTrue(os.path.exists(addr))
342
343
344 @unittest.skipUnless(hasattr(asyncio, 'ProactorEventLoop'), 'Windows only')
345 class ProactorStartServerTests(BaseStartServer, unittest.TestCase):
346
347 def new_loop(self):
348 return asyncio.ProactorEventLoop()
349
350
351 if __name__ == '__main__':
352 unittest.main()