Coverage for Lib/asyncio/selector_events.py: 88%
938 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 05:46 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 05:46 +0000
1"""Event loop using a selector and related classes.
3A selector is a "notify-when-ready" multiplexer. For a subclass which
4also includes support for signal handling, see the unix_events sub-module.
5"""
7__all__ = 'BaseSelectorEventLoop',
9import collections
10import errno
11import functools
12import itertools
13import os
14import selectors
15import socket
16import warnings
17import weakref
18try:
19 import ssl
20except ImportError: # pragma: no cover
21 ssl = None
23from . import base_events
24from . import constants
25from . import events
26from . import futures
27from . import protocols
28from . import sslproto
29from . import transports
30from . import trsock
31from .log import logger
33_HAS_SENDMSG = hasattr(socket.socket, 'sendmsg')
35if _HAS_SENDMSG: 35 ↛ 42line 35 didn't jump to line 42 because the condition on line 35 was always true
36 try:
37 SC_IOV_MAX = os.sysconf('SC_IOV_MAX')
38 except OSError:
39 # Fallback to send
40 _HAS_SENDMSG = False
42def _test_selector_event(selector, fd, event):
43 # Test if the selector is monitoring 'event' events
44 # for the file descriptor 'fd'.
45 try:
46 key = selector.get_key(fd)
47 except KeyError:
48 return False
49 else:
50 return bool(key.events & event)
53class BaseSelectorEventLoop(base_events.BaseEventLoop):
54 """Selector event loop.
56 See events.AbstractEventLoop for API specification.
57 """
59 def __init__(self, selector=None):
60 super().__init__()
62 if selector is None:
63 selector = selectors.DefaultSelector()
64 logger.debug('Using selector: %s', selector.__class__.__name__)
65 self._selector = selector
66 self._make_self_pipe()
67 self._transports = weakref.WeakValueDictionary()
69 def _make_socket_transport(self, sock, protocol, waiter=None, *,
70 extra=None, server=None, context=None):
71 self._ensure_fd_no_transport(sock)
72 return _SelectorSocketTransport(self, sock, protocol, waiter,
73 extra, server, context=context)
75 def _make_ssl_transport(
76 self, rawsock, protocol, sslcontext, waiter=None,
77 *, server_side=False, server_hostname=None,
78 extra=None, server=None,
79 ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
80 ssl_shutdown_timeout=constants.SSL_SHUTDOWN_TIMEOUT,
81 context=None,
82 ):
83 self._ensure_fd_no_transport(rawsock)
84 ssl_protocol = sslproto.SSLProtocol(
85 self, protocol, sslcontext, waiter,
86 server_side, server_hostname,
87 ssl_handshake_timeout=ssl_handshake_timeout,
88 ssl_shutdown_timeout=ssl_shutdown_timeout,
89 )
90 _SelectorSocketTransport(self, rawsock, ssl_protocol,
91 extra=extra, server=server, context=context)
92 return ssl_protocol._app_transport
94 def _make_datagram_transport(self, sock, protocol,
95 address=None, waiter=None, extra=None):
96 self._ensure_fd_no_transport(sock)
97 return _SelectorDatagramTransport(self, sock, protocol,
98 address, waiter, extra)
100 def close(self):
101 if self.is_running():
102 raise RuntimeError("Cannot close a running event loop")
103 if self.is_closed():
104 return
105 self._close_self_pipe()
106 super().close()
107 if self._selector is not None:
108 self._selector.close()
109 self._selector = None
111 def _close_self_pipe(self):
112 self._remove_reader(self._ssock.fileno())
113 self._ssock.close()
114 self._ssock = None
115 self._csock.close()
116 self._csock = None
117 self._internal_fds -= 1
119 def _make_self_pipe(self):
120 # A self-socket, really. :-)
121 self._ssock, self._csock = socket.socketpair()
122 self._ssock.setblocking(False)
123 self._csock.setblocking(False)
124 self._internal_fds += 1
125 self._add_reader(self._ssock.fileno(), self._read_from_self)
127 def _process_self_data(self, data):
128 pass
130 def _read_from_self(self):
131 while True:
132 try:
133 data = self._ssock.recv(4096)
134 if not data: 134 ↛ 135line 134 didn't jump to line 135 because the condition on line 134 was never true
135 break
136 self._process_self_data(data)
137 except InterruptedError:
138 continue
139 except BlockingIOError:
140 break
142 def _write_to_self(self):
143 # This may be called from a different thread, possibly after
144 # _close_self_pipe() has been called or even while it is
145 # running. Guard for self._csock being None or closed. When
146 # a socket is closed, send() raises OSError (with errno set to
147 # EBADF, but let's not rely on the exact error code).
148 csock = self._csock
149 if csock is None: 149 ↛ 150line 149 didn't jump to line 150 because the condition on line 149 was never true
150 return
152 try:
153 csock.send(b'\0')
154 except OSError:
155 if self._debug: 155 ↛ 156line 155 didn't jump to line 156 because the condition on line 155 was never true
156 logger.debug("Fail to write a null byte into the "
157 "self-pipe socket",
158 exc_info=True)
160 def _start_serving(self, protocol_factory, sock,
161 sslcontext=None, server=None, backlog=100,
162 ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
163 ssl_shutdown_timeout=constants.SSL_SHUTDOWN_TIMEOUT, context=None):
164 self._add_reader(sock.fileno(), self._accept_connection,
165 protocol_factory, sock, sslcontext, server, backlog,
166 ssl_handshake_timeout, ssl_shutdown_timeout, context)
168 def _accept_connection(
169 self, protocol_factory, sock,
170 sslcontext=None, server=None, backlog=100,
171 ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
172 ssl_shutdown_timeout=constants.SSL_SHUTDOWN_TIMEOUT, context=None):
173 # This method is only called once for each event loop tick where the
174 # listening socket has triggered an EVENT_READ. There may be multiple
175 # connections waiting for an .accept() so it is called in a loop.
176 # See https://bugs.python.org/issue27906 for more details.
177 for _ in range(backlog + 1):
178 try:
179 conn, addr = sock.accept()
180 if self._debug:
181 logger.debug("%r got a new connection from %r: %r",
182 server, addr, conn)
183 conn.setblocking(False)
184 except ConnectionAbortedError:
185 # Discard connections that were aborted before accept().
186 continue
187 except (BlockingIOError, InterruptedError):
188 # Early exit because of a signal or
189 # the socket accept buffer is empty.
190 return
191 except OSError as exc:
192 # There's nowhere to send the error, so just log it.
193 if exc.errno in (errno.EMFILE, errno.ENFILE, 193 ↛ 211line 193 didn't jump to line 211 because the condition on line 193 was always true
194 errno.ENOBUFS, errno.ENOMEM):
195 # Some platforms (e.g. Linux keep reporting the FD as
196 # ready, so we remove the read handler temporarily.
197 # We'll try again in a while.
198 self.call_exception_handler({
199 'message': 'socket.accept() out of system resource',
200 'exception': exc,
201 'socket': trsock.TransportSocket(sock),
202 })
203 self._remove_reader(sock.fileno())
204 self.call_later(constants.ACCEPT_RETRY_DELAY,
205 self._start_serving,
206 protocol_factory, sock, sslcontext, server,
207 backlog, ssl_handshake_timeout,
208 ssl_shutdown_timeout, context)
209 return
210 else:
211 raise # The event loop will catch, log and ignore it.
212 else:
213 extra = {'peername': addr}
214 conn_context = context.copy() if context is not None else None
215 accept = self._accept_connection2(
216 protocol_factory, conn, extra, sslcontext, server,
217 ssl_handshake_timeout, ssl_shutdown_timeout, context=conn_context)
218 self.create_task(accept, context=conn_context)
220 async def _accept_connection2(
221 self, protocol_factory, conn, extra,
222 sslcontext=None, server=None,
223 ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
224 ssl_shutdown_timeout=constants.SSL_SHUTDOWN_TIMEOUT, context=None):
225 protocol = None
226 transport = None
227 try:
228 protocol = protocol_factory()
229 if server is not None and not server.is_serving():
230 # The server was closed after the connection was accepted.
231 conn.close()
232 return
233 waiter = self.create_future()
234 if sslcontext:
235 transport = self._make_ssl_transport(
236 conn, protocol, sslcontext, waiter=waiter,
237 server_side=True, extra=extra, server=server,
238 ssl_handshake_timeout=ssl_handshake_timeout,
239 ssl_shutdown_timeout=ssl_shutdown_timeout,
240 context=context)
241 else:
242 transport = self._make_socket_transport(
243 conn, protocol, waiter=waiter, extra=extra,
244 server=server, context=context)
246 try:
247 await waiter
248 except BaseException:
249 transport.close()
250 # gh-109534: When an exception is raised by the SSLProtocol object the
251 # exception set in this future can keep the protocol object alive and
252 # cause a reference cycle.
253 waiter = None
254 raise
255 # It's now up to the protocol to handle the connection.
257 except (SystemExit, KeyboardInterrupt):
258 raise
259 except BaseException as exc:
260 if transport is None:
261 conn.close()
262 if transport is None or self._debug:
263 context = {
264 'message':
265 'Error on transport creation for incoming connection',
266 'exception': exc,
267 }
268 if protocol is not None:
269 context['protocol'] = protocol
270 if transport is not None: 270 ↛ 271line 270 didn't jump to line 271 because the condition on line 270 was never true
271 context['transport'] = transport
272 self.call_exception_handler(context)
274 def _ensure_fd_no_transport(self, fd):
275 fileno = fd
276 if not isinstance(fileno, int):
277 try:
278 fileno = int(fileno.fileno())
279 except (AttributeError, TypeError, ValueError):
280 # This code matches selectors._fileobj_to_fd function.
281 raise ValueError(f"Invalid file object: {fd!r}") from None
282 transport = self._transports.get(fileno)
283 if transport and not transport.is_closing():
284 raise RuntimeError(
285 f'File descriptor {fd!r} is used by transport '
286 f'{transport!r}')
288 def _add_reader(self, fd, callback, *args, context=None):
289 self._check_closed()
290 handle = events.Handle(callback, args, self, context=context)
291 key = self._selector.get_map().get(fd)
292 if key is None:
293 self._selector.register(fd, selectors.EVENT_READ,
294 (handle, None))
295 else:
296 mask, (reader, writer) = key.events, key.data
297 self._selector.modify(fd, mask | selectors.EVENT_READ,
298 (handle, writer))
299 if reader is not None:
300 reader.cancel()
301 return handle
303 def _remove_reader(self, fd):
304 if self.is_closed():
305 return False
306 key = self._selector.get_map().get(fd)
307 if key is None:
308 return False
309 mask, (reader, writer) = key.events, key.data
310 mask &= ~selectors.EVENT_READ
311 if not mask:
312 self._selector.unregister(fd)
313 else:
314 self._selector.modify(fd, mask, (None, writer))
316 if reader is not None:
317 reader.cancel()
318 return True
319 else:
320 return False
322 def _add_writer(self, fd, callback, *args, context=None):
323 self._check_closed()
324 handle = events.Handle(callback, args, self, context=context)
325 key = self._selector.get_map().get(fd)
326 if key is None:
327 self._selector.register(fd, selectors.EVENT_WRITE,
328 (None, handle))
329 else:
330 mask, (reader, writer) = key.events, key.data
331 self._selector.modify(fd, mask | selectors.EVENT_WRITE,
332 (reader, handle))
333 if writer is not None:
334 writer.cancel()
335 return handle
337 def _remove_writer(self, fd):
338 """Remove a writer callback."""
339 if self.is_closed():
340 return False
341 key = self._selector.get_map().get(fd)
342 if key is None:
343 return False
344 mask, (reader, writer) = key.events, key.data
345 # Remove both writer and connector.
346 mask &= ~selectors.EVENT_WRITE
347 if not mask:
348 self._selector.unregister(fd)
349 else:
350 self._selector.modify(fd, mask, (reader, None))
352 if writer is not None:
353 writer.cancel()
354 return True
355 else:
356 return False
358 def add_reader(self, fd, callback, *args):
359 """Add a reader callback."""
360 self._ensure_fd_no_transport(fd)
361 self._add_reader(fd, callback, *args)
363 def remove_reader(self, fd):
364 """Remove a reader callback."""
365 self._ensure_fd_no_transport(fd)
366 return self._remove_reader(fd)
368 def add_writer(self, fd, callback, *args):
369 """Add a writer callback.."""
370 self._ensure_fd_no_transport(fd)
371 self._add_writer(fd, callback, *args)
373 def remove_writer(self, fd):
374 """Remove a writer callback."""
375 self._ensure_fd_no_transport(fd)
376 return self._remove_writer(fd)
378 async def sock_recv(self, sock, n):
379 """Receive data from the socket.
381 The return value is a bytes object representing the data received.
382 The maximum amount of data to be received at once is specified by
383 nbytes.
384 """
385 base_events._check_ssl_socket(sock)
386 if self._debug and sock.gettimeout() != 0:
387 raise ValueError("the socket must be non-blocking")
388 try:
389 return sock.recv(n)
390 except (BlockingIOError, InterruptedError):
391 pass
392 fut = self.create_future()
393 fd = sock.fileno()
394 self._ensure_fd_no_transport(fd)
395 handle = self._add_reader(fd, self._sock_recv, fut, sock, n)
396 fut.add_done_callback(
397 functools.partial(self._sock_read_done, fd, handle=handle))
398 return await fut
400 def _sock_read_done(self, fd, fut, handle=None):
401 if handle is None or not handle.cancelled():
402 self.remove_reader(fd)
404 def _sock_recv(self, fut, sock, n):
405 # _sock_recv() can add itself as an I/O callback if the operation can't
406 # be done immediately. Don't use it directly, call sock_recv().
407 if fut.done(): 407 ↛ 408line 407 didn't jump to line 408 because the condition on line 407 was never true
408 return
409 try:
410 data = sock.recv(n)
411 except (BlockingIOError, InterruptedError):
412 return # try again next time
413 except (SystemExit, KeyboardInterrupt):
414 raise
415 except BaseException as exc:
416 fut.set_exception(exc)
417 else:
418 fut.set_result(data)
420 async def sock_recv_into(self, sock, buf):
421 """Receive data from the socket.
423 The received data is written into *buf* (a writable buffer).
424 The return value is the number of bytes written.
425 """
426 base_events._check_ssl_socket(sock)
427 if self._debug and sock.gettimeout() != 0:
428 raise ValueError("the socket must be non-blocking")
429 try:
430 return sock.recv_into(buf)
431 except (BlockingIOError, InterruptedError):
432 pass
433 fut = self.create_future()
434 fd = sock.fileno()
435 self._ensure_fd_no_transport(fd)
436 handle = self._add_reader(fd, self._sock_recv_into, fut, sock, buf)
437 fut.add_done_callback(
438 functools.partial(self._sock_read_done, fd, handle=handle))
439 return await fut
441 def _sock_recv_into(self, fut, sock, buf):
442 # _sock_recv_into() can add itself as an I/O callback if the operation
443 # can't be done immediately. Don't use it directly, call
444 # sock_recv_into().
445 if fut.done(): 445 ↛ 446line 445 didn't jump to line 446 because the condition on line 445 was never true
446 return
447 try:
448 nbytes = sock.recv_into(buf)
449 except (BlockingIOError, InterruptedError):
450 return # try again next time
451 except (SystemExit, KeyboardInterrupt):
452 raise
453 except BaseException as exc:
454 fut.set_exception(exc)
455 else:
456 fut.set_result(nbytes)
458 async def sock_recvfrom(self, sock, bufsize):
459 """Receive a datagram from a datagram socket.
461 The return value is a tuple of (bytes, address) representing the
462 datagram received and the address it came from.
463 The maximum amount of data to be received at once is specified by
464 nbytes.
465 """
466 base_events._check_ssl_socket(sock)
467 if self._debug and sock.gettimeout() != 0: 467 ↛ 468line 467 didn't jump to line 468 because the condition on line 467 was never true
468 raise ValueError("the socket must be non-blocking")
469 try:
470 return sock.recvfrom(bufsize)
471 except (BlockingIOError, InterruptedError):
472 pass
473 fut = self.create_future()
474 fd = sock.fileno()
475 self._ensure_fd_no_transport(fd)
476 handle = self._add_reader(fd, self._sock_recvfrom, fut, sock, bufsize)
477 fut.add_done_callback(
478 functools.partial(self._sock_read_done, fd, handle=handle))
479 return await fut
481 def _sock_recvfrom(self, fut, sock, bufsize):
482 # _sock_recvfrom() can add itself as an I/O callback if the operation
483 # can't be done immediately. Don't use it directly, call
484 # sock_recvfrom().
485 if fut.done(): 485 ↛ 486line 485 didn't jump to line 486 because the condition on line 485 was never true
486 return
487 try:
488 result = sock.recvfrom(bufsize)
489 except (BlockingIOError, InterruptedError):
490 return # try again next time
491 except (SystemExit, KeyboardInterrupt):
492 raise
493 except BaseException as exc:
494 fut.set_exception(exc)
495 else:
496 fut.set_result(result)
498 async def sock_recvfrom_into(self, sock, buf, nbytes=0):
499 """Receive data from the socket.
501 The received data is written into *buf* (a writable buffer).
502 The return value is a tuple of (number of bytes written, address).
503 """
504 base_events._check_ssl_socket(sock)
505 if self._debug and sock.gettimeout() != 0: 505 ↛ 506line 505 didn't jump to line 506 because the condition on line 505 was never true
506 raise ValueError("the socket must be non-blocking")
507 if not nbytes:
508 nbytes = len(buf)
510 try:
511 return sock.recvfrom_into(buf, nbytes)
512 except (BlockingIOError, InterruptedError):
513 pass
514 fut = self.create_future()
515 fd = sock.fileno()
516 self._ensure_fd_no_transport(fd)
517 handle = self._add_reader(fd, self._sock_recvfrom_into, fut, sock, buf,
518 nbytes)
519 fut.add_done_callback(
520 functools.partial(self._sock_read_done, fd, handle=handle))
521 return await fut
523 def _sock_recvfrom_into(self, fut, sock, buf, bufsize):
524 # _sock_recv_into() can add itself as an I/O callback if the operation
525 # can't be done immediately. Don't use it directly, call
526 # sock_recv_into().
527 if fut.done(): 527 ↛ 528line 527 didn't jump to line 528 because the condition on line 527 was never true
528 return
529 try:
530 result = sock.recvfrom_into(buf, bufsize)
531 except (BlockingIOError, InterruptedError):
532 return # try again next time
533 except (SystemExit, KeyboardInterrupt):
534 raise
535 except BaseException as exc:
536 fut.set_exception(exc)
537 else:
538 fut.set_result(result)
540 async def sock_sendall(self, sock, data):
541 """Send data to the socket.
543 The socket must be connected to a remote socket. This method
544 continues to send data from data until either all data has been
545 sent or an error occurs. None is returned on success. On error,
546 an exception is raised, and there is no way to determine how much
547 data, if any, was successfully processed by the receiving end of
548 the connection.
549 """
550 base_events._check_ssl_socket(sock)
551 if self._debug and sock.gettimeout() != 0:
552 raise ValueError("the socket must be non-blocking")
553 try:
554 n = sock.send(data)
555 except (BlockingIOError, InterruptedError):
556 n = 0
558 if n == len(data):
559 # all data sent
560 return
562 fut = self.create_future()
563 fd = sock.fileno()
564 self._ensure_fd_no_transport(fd)
565 # use a trick with a list in closure to store a mutable state
566 handle = self._add_writer(fd, self._sock_sendall, fut, sock,
567 memoryview(data), [n])
568 fut.add_done_callback(
569 functools.partial(self._sock_write_done, fd, handle=handle))
570 return await fut
572 def _sock_sendall(self, fut, sock, view, pos):
573 if fut.done(): 573 ↛ 575line 573 didn't jump to line 575 because the condition on line 573 was never true
574 # Future cancellation can be scheduled on previous loop iteration
575 return
576 start = pos[0]
577 try:
578 n = sock.send(view[start:])
579 except (BlockingIOError, InterruptedError):
580 return
581 except (SystemExit, KeyboardInterrupt):
582 raise
583 except BaseException as exc:
584 fut.set_exception(exc)
585 return
587 start += n
589 if start == len(view):
590 fut.set_result(None)
591 else:
592 pos[0] = start
594 async def sock_sendto(self, sock, data, address):
595 """Send a datagram from sock to address.
597 The socket does not have to be connected. This method sends the
598 whole datagram in a single call. Return the number of bytes sent.
599 """
600 base_events._check_ssl_socket(sock)
601 if self._debug and sock.gettimeout() != 0: 601 ↛ 602line 601 didn't jump to line 602 because the condition on line 601 was never true
602 raise ValueError("the socket must be non-blocking")
603 try:
604 return sock.sendto(data, address)
605 except (BlockingIOError, InterruptedError):
606 pass
608 fut = self.create_future()
609 fd = sock.fileno()
610 self._ensure_fd_no_transport(fd)
611 # use a trick with a list in closure to store a mutable state
612 handle = self._add_writer(fd, self._sock_sendto, fut, sock, data,
613 address)
614 fut.add_done_callback(
615 functools.partial(self._sock_write_done, fd, handle=handle))
616 return await fut
618 def _sock_sendto(self, fut, sock, data, address):
619 if fut.done(): 619 ↛ 621line 619 didn't jump to line 621 because the condition on line 619 was never true
620 # Future cancellation can be scheduled on previous loop iteration
621 return
622 try:
623 n = sock.sendto(data, 0, address)
624 except (BlockingIOError, InterruptedError):
625 return
626 except (SystemExit, KeyboardInterrupt):
627 raise
628 except BaseException as exc:
629 fut.set_exception(exc)
630 else:
631 fut.set_result(n)
633 async def sock_connect(self, sock, address):
634 """Connect to a remote socket at address.
636 This method is a coroutine.
637 """
638 base_events._check_ssl_socket(sock)
639 if self._debug and sock.gettimeout() != 0:
640 raise ValueError("the socket must be non-blocking")
642 if sock.family == socket.AF_INET or (
643 base_events._HAS_IPv6 and sock.family == socket.AF_INET6):
644 resolved = await self._ensure_resolved(
645 address, family=sock.family, type=sock.type, proto=sock.proto,
646 loop=self,
647 )
648 _, _, _, _, address = resolved[0]
650 fut = self.create_future()
651 self._sock_connect(fut, sock, address)
652 try:
653 return await fut
654 finally:
655 # Needed to break cycles when an exception occurs.
656 fut = None
658 def _sock_connect(self, fut, sock, address):
659 fd = sock.fileno()
660 try:
661 sock.connect(address)
662 except (BlockingIOError, InterruptedError):
663 # Issue #23618: When the C function connect() fails with EINTR, the
664 # connection runs in background. We have to wait until the socket
665 # becomes writable to be notified when the connection succeed or
666 # fails.
667 self._ensure_fd_no_transport(fd)
668 handle = self._add_writer(
669 fd, self._sock_connect_cb, fut, sock, address)
670 fut.add_done_callback(
671 functools.partial(self._sock_write_done, fd, handle=handle))
672 except (SystemExit, KeyboardInterrupt):
673 raise
674 except BaseException as exc:
675 fut.set_exception(exc)
676 else:
677 fut.set_result(None)
678 finally:
679 fut = None
681 def _sock_write_done(self, fd, fut, handle=None):
682 if handle is None or not handle.cancelled():
683 self.remove_writer(fd)
685 def _sock_connect_cb(self, fut, sock, address):
686 if fut.done(): 686 ↛ 687line 686 didn't jump to line 687 because the condition on line 686 was never true
687 return
689 try:
690 err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
691 if err != 0:
692 # Jump to any except clause below.
693 raise OSError(err, f'Connect call failed {address}')
694 except (BlockingIOError, InterruptedError):
695 # socket is still registered, the callback will be retried later
696 pass
697 except (SystemExit, KeyboardInterrupt):
698 raise
699 except BaseException as exc:
700 fut.set_exception(exc)
701 else:
702 fut.set_result(None)
703 finally:
704 fut = None
706 async def sock_accept(self, sock):
707 """Accept a connection.
709 The socket must be bound to an address and listening for
710 connections. The return value is a pair (conn, address) where
711 conn is a new socket object usable to send and receive data on the
712 connection, and address is the address bound to the socket on the
713 other end of the connection.
714 """
715 base_events._check_ssl_socket(sock)
716 if self._debug and sock.gettimeout() != 0:
717 raise ValueError("the socket must be non-blocking")
718 fut = self.create_future()
719 self._sock_accept(fut, sock)
720 return await fut
722 def _sock_accept(self, fut, sock):
723 # gh-153761: _sock_accept must not scheduled with already cancelled future
724 if fut.done():
725 return
726 fd = sock.fileno()
727 try:
728 conn, address = sock.accept()
729 conn.setblocking(False)
730 except (BlockingIOError, InterruptedError):
731 self._ensure_fd_no_transport(fd)
732 handle = self._add_reader(fd, self._sock_accept, fut, sock)
733 fut.add_done_callback(
734 functools.partial(self._sock_read_done, fd, handle=handle))
735 except (SystemExit, KeyboardInterrupt):
736 raise
737 except BaseException as exc:
738 fut.set_exception(exc)
739 else:
740 fut.set_result((conn, address))
742 async def _sendfile_native(self, transp, file, offset, count):
743 del self._transports[transp._sock_fd]
744 resume_reading = transp.is_reading()
745 transp.pause_reading()
746 try:
747 await transp._make_empty_waiter()
748 return await self.sock_sendfile(transp._sock, file, offset, count,
749 fallback=False)
750 finally:
751 transp._reset_empty_waiter()
752 if resume_reading:
753 transp.resume_reading()
754 self._transports[transp._sock_fd] = transp
756 def _process_events(self, event_list):
757 for key, mask in event_list:
758 fileobj, (reader, writer) = key.fileobj, key.data
759 if mask & selectors.EVENT_READ and reader is not None:
760 if reader._cancelled:
761 self._remove_reader(fileobj)
762 else:
763 self._add_callback(reader)
764 if mask & selectors.EVENT_WRITE and writer is not None:
765 if writer._cancelled:
766 self._remove_writer(fileobj)
767 else:
768 self._add_callback(writer)
770 def _stop_serving(self, sock):
771 self._remove_reader(sock.fileno())
772 sock.close()
775class _SelectorTransport(transports._FlowControlMixin,
776 transports.Transport):
778 max_size = 256 * 1024 # Buffer size passed to recv().
780 # Attribute used in the destructor: it must be set even if the constructor
781 # is not called (see _SelectorSslTransport which may start by raising an
782 # exception)
783 _sock = None
785 def __init__(self, loop, sock, protocol, extra=None, server=None, context=None):
786 super().__init__(extra, loop)
787 self._extra['socket'] = trsock.TransportSocket(sock)
788 try:
789 self._extra['sockname'] = sock.getsockname()
790 except OSError:
791 self._extra['sockname'] = None
792 if 'peername' not in self._extra:
793 try:
794 self._extra['peername'] = sock.getpeername()
795 except socket.error:
796 self._extra['peername'] = None
797 self._sock = sock
798 self._sock_fd = sock.fileno()
799 self._context = context
800 self._protocol_connected = False
801 self.set_protocol(protocol)
803 self._server = server
804 self._buffer = collections.deque()
805 self._buffer_size = 0
806 self._conn_lost = 0 # Set when call to connection_lost scheduled.
807 self._closing = False # Set when close() called.
808 self._paused = False # Set when pause_reading() called
810 if self._server is not None:
811 self._server._attach(self)
812 loop._transports[self._sock_fd] = self
814 def __repr__(self):
815 info = [self.__class__.__name__]
816 if self._sock is None: 816 ↛ 817line 816 didn't jump to line 817 because the condition on line 816 was never true
817 info.append('closed')
818 elif self._closing:
819 info.append('closing')
820 info.append(f'fd={self._sock_fd}')
821 # test if the transport was closed
822 if self._loop is not None and not self._loop.is_closed():
823 polling = _test_selector_event(self._loop._selector,
824 self._sock_fd, selectors.EVENT_READ)
825 if polling:
826 info.append('read=polling')
827 else:
828 info.append('read=idle')
830 polling = _test_selector_event(self._loop._selector,
831 self._sock_fd,
832 selectors.EVENT_WRITE)
833 if polling: 833 ↛ 834line 833 didn't jump to line 834 because the condition on line 833 was never true
834 state = 'polling'
835 else:
836 state = 'idle'
838 bufsize = self.get_write_buffer_size()
839 info.append(f'write=<{state}, bufsize={bufsize}>')
840 return '<{}>'.format(' '.join(info))
842 def abort(self):
843 self._force_close(None)
845 def set_protocol(self, protocol):
846 self._protocol = protocol
847 self._protocol_connected = True
849 def get_protocol(self):
850 return self._protocol
852 def is_closing(self):
853 return self._closing
855 def is_reading(self):
856 return not self.is_closing() and not self._paused
858 def pause_reading(self):
859 if not self.is_reading():
860 return
861 self._paused = True
862 self._loop._remove_reader(self._sock_fd)
863 if self._loop.get_debug():
864 logger.debug("%r pauses reading", self)
866 def resume_reading(self):
867 if self._closing or not self._paused:
868 return
869 self._paused = False
870 self._add_reader(self._sock_fd, self._read_ready)
871 if self._loop.get_debug(): 871 ↛ 872line 871 didn't jump to line 872 because the condition on line 871 was never true
872 logger.debug("%r resumes reading", self)
874 def close(self):
875 if self._closing:
876 return
877 self._closing = True
878 self._loop._remove_reader(self._sock_fd)
879 if not self._buffer:
880 self._conn_lost += 1
881 self._loop._remove_writer(self._sock_fd)
882 self._call_soon(self._call_connection_lost, None)
884 def __del__(self, _warn=warnings.warn):
885 if self._sock is not None: 885 ↛ 886line 885 didn't jump to line 886 because the condition on line 885 was never true
886 _warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
887 self._sock.close()
888 if self._server is not None:
889 self._server._detach(self)
891 def _fatal_error(self, exc, message='Fatal error on transport'):
892 # Should be called from exception handler only.
893 if isinstance(exc, OSError):
894 if self._loop.get_debug(): 894 ↛ 895line 894 didn't jump to line 895 because the condition on line 894 was never true
895 logger.debug("%r: %s", self, message, exc_info=True)
896 else:
897 self._loop.call_exception_handler({
898 'message': message,
899 'exception': exc,
900 'transport': self,
901 'protocol': self._protocol,
902 })
903 self._force_close(exc)
905 def _force_close(self, exc):
906 if self._conn_lost:
907 return
908 if self._buffer:
909 self._buffer.clear()
910 self._buffer_size = 0
911 self._loop._remove_writer(self._sock_fd)
912 if not self._closing:
913 self._closing = True
914 self._loop._remove_reader(self._sock_fd)
915 self._conn_lost += 1
916 self._call_soon(self._call_connection_lost, exc)
918 def _call_connection_lost(self, exc):
919 try:
920 if self._protocol_connected: 920 ↛ 923line 920 didn't jump to line 923 because the condition on line 920 was always true
921 self._protocol.connection_lost(exc)
922 finally:
923 self._sock.close()
924 self._sock = None
925 self._protocol = None
926 self._loop = None
927 server = self._server
928 if server is not None:
929 server._detach(self)
930 self._server = None
932 def get_write_buffer_size(self):
933 return self._buffer_size
935 def _add_reader(self, fd, callback, *args):
936 if not self.is_reading():
937 return
938 self._loop._add_reader(fd, callback, *args, context=self._context)
940 def _add_writer(self, fd, callback, *args):
941 self._loop._add_writer(fd, callback, *args, context=self._context)
943 def _call_soon(self, callback, *args):
944 self._loop.call_soon(callback, *args, context=self._context)
946class _SelectorSocketTransport(_SelectorTransport):
948 _start_tls_compatible = True
949 _sendfile_compatible = constants._SendfileMode.TRY_NATIVE
951 def __init__(self, loop, sock, protocol, waiter=None,
952 extra=None, server=None, context=None):
953 self._read_ready_cb = None
954 super().__init__(loop, sock, protocol, extra, server, context)
955 self._eof = False
956 self._empty_waiter = None
957 if _HAS_SENDMSG: 957 ↛ 960line 957 didn't jump to line 960 because the condition on line 957 was always true
958 self._write_ready = self._write_sendmsg
959 else:
960 self._write_ready = self._write_send
961 # Disable the Nagle algorithm -- small writes will be
962 # sent without waiting for the TCP ACK. This generally
963 # decreases the latency (in some cases significantly.)
964 base_events._set_nodelay(self._sock)
966 self._call_soon(self._protocol.connection_made, self)
967 # only start reading when connection_made() has been called
968 self._call_soon(self._add_reader, self._sock_fd, self._read_ready)
969 if waiter is not None:
970 # only wake up the waiter when connection_made() has been called
971 self._call_soon(futures._set_result_unless_cancelled, waiter, None)
973 def set_protocol(self, protocol):
974 if isinstance(protocol, protocols.BufferedProtocol):
975 self._read_ready_cb = self._read_ready__get_buffer
976 else:
977 self._read_ready_cb = self._read_ready__data_received
979 super().set_protocol(protocol)
981 def _read_ready(self):
982 self._read_ready_cb()
984 def _read_ready__get_buffer(self):
985 if self._conn_lost: 985 ↛ 986line 985 didn't jump to line 986 because the condition on line 985 was never true
986 return
988 try:
989 buf = self._protocol.get_buffer(-1)
990 if not len(buf):
991 raise RuntimeError('get_buffer() returned an empty buffer')
992 except (SystemExit, KeyboardInterrupt):
993 raise
994 except BaseException as exc:
995 self._fatal_error(
996 exc, 'Fatal error: protocol.get_buffer() call failed.')
997 return
999 try:
1000 nbytes = self._sock.recv_into(buf)
1001 except (BlockingIOError, InterruptedError):
1002 return
1003 except (SystemExit, KeyboardInterrupt):
1004 raise
1005 except BaseException as exc:
1006 self._fatal_error(exc, 'Fatal read error on socket transport')
1007 return
1009 if not nbytes:
1010 self._read_ready__on_eof()
1011 return
1013 try:
1014 self._protocol.buffer_updated(nbytes)
1015 except (SystemExit, KeyboardInterrupt):
1016 raise
1017 except BaseException as exc:
1018 self._fatal_error(
1019 exc, 'Fatal error: protocol.buffer_updated() call failed.')
1021 def _read_ready__data_received(self):
1022 if self._conn_lost: 1022 ↛ 1023line 1022 didn't jump to line 1023 because the condition on line 1022 was never true
1023 return
1024 try:
1025 data = self._sock.recv(self.max_size)
1026 except (BlockingIOError, InterruptedError):
1027 return
1028 except (SystemExit, KeyboardInterrupt):
1029 raise
1030 except BaseException as exc:
1031 self._fatal_error(exc, 'Fatal read error on socket transport')
1032 return
1034 if not data:
1035 self._read_ready__on_eof()
1036 return
1038 try:
1039 self._protocol.data_received(data)
1040 except (SystemExit, KeyboardInterrupt):
1041 raise
1042 except BaseException as exc:
1043 self._fatal_error(
1044 exc, 'Fatal error: protocol.data_received() call failed.')
1046 def _read_ready__on_eof(self):
1047 if self._loop.get_debug():
1048 logger.debug("%r received EOF", self)
1050 try:
1051 keep_open = self._protocol.eof_received()
1052 except (SystemExit, KeyboardInterrupt):
1053 raise
1054 except BaseException as exc:
1055 self._fatal_error(
1056 exc, 'Fatal error: protocol.eof_received() call failed.')
1057 return
1059 if keep_open:
1060 # We're keeping the connection open so the
1061 # protocol can write more, but we still can't
1062 # receive more, so remove the reader callback.
1063 self._loop._remove_reader(self._sock_fd)
1064 else:
1065 self.close()
1067 def write(self, data):
1068 if not isinstance(data, (bytes, bytearray, memoryview)):
1069 raise TypeError(f'data argument must be a bytes, bytearray, or memoryview '
1070 f'object, not {type(data).__name__!r}')
1071 if self._eof: 1071 ↛ 1072line 1071 didn't jump to line 1072 because the condition on line 1071 was never true
1072 raise RuntimeError('Cannot call write() after write_eof()')
1073 if self._empty_waiter is not None:
1074 raise RuntimeError('unable to write; sendfile is in progress')
1075 if not data:
1076 return
1078 if self._conn_lost:
1079 if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
1080 logger.warning('socket.send() raised exception.')
1081 self._conn_lost += 1
1082 return
1084 if not self._buffer:
1085 # Optimization: try to send now.
1086 try:
1087 n = self._sock.send(data)
1088 except (BlockingIOError, InterruptedError):
1089 pass
1090 except (SystemExit, KeyboardInterrupt):
1091 raise
1092 except BaseException as exc:
1093 self._fatal_error(exc, 'Fatal write error on socket transport')
1094 return
1095 else:
1096 data = memoryview(data)[n:]
1097 if not data:
1098 return
1099 # Not all was written; register write handler.
1100 self._add_writer(self._sock_fd, self._write_ready)
1102 # Add it to the buffer as a view, so partial sends don't copy it.
1103 if not isinstance(data, memoryview):
1104 data = memoryview(data)
1105 self._buffer.append(data)
1106 self._buffer_size += len(data)
1107 self._maybe_pause_protocol()
1109 def _get_sendmsg_buffer(self):
1110 return itertools.islice(self._buffer, SC_IOV_MAX)
1112 def _write_sendmsg(self):
1113 assert self._buffer, 'Data should not be empty'
1114 if self._conn_lost: 1114 ↛ 1115line 1114 didn't jump to line 1115 because the condition on line 1114 was never true
1115 return
1116 try:
1117 nbytes = self._sock.sendmsg(self._get_sendmsg_buffer())
1118 self._adjust_leftover_buffer(nbytes)
1119 except (BlockingIOError, InterruptedError):
1120 pass
1121 except (SystemExit, KeyboardInterrupt):
1122 raise
1123 except BaseException as exc:
1124 self._loop._remove_writer(self._sock_fd)
1125 self._buffer.clear()
1126 self._buffer_size = 0
1127 self._fatal_error(exc, 'Fatal write error on socket transport')
1128 if self._empty_waiter is not None: 1128 ↛ 1129line 1128 didn't jump to line 1129 because the condition on line 1128 was never true
1129 self._empty_waiter.set_exception(exc)
1130 else:
1131 self._maybe_resume_protocol() # May append to buffer.
1132 if not self._buffer:
1133 self._loop._remove_writer(self._sock_fd)
1134 if self._empty_waiter is not None:
1135 self._empty_waiter.set_result(None)
1136 # gh-156512: don't let _call_connection_lost be called twice
1137 if self._closing and not self._conn_lost:
1138 self._conn_lost += 1
1139 self._call_connection_lost(None)
1140 elif self._eof: 1140 ↛ 1141line 1140 didn't jump to line 1141 because the condition on line 1140 was never true
1141 self._sock.shutdown(socket.SHUT_WR)
1143 def _adjust_leftover_buffer(self, nbytes: int) -> None:
1144 self._buffer_size -= nbytes
1145 buffer = self._buffer
1146 while nbytes:
1147 b = buffer.popleft()
1148 b_len = len(b)
1149 if b_len <= nbytes:
1150 nbytes -= b_len
1151 else:
1152 buffer.appendleft(b[nbytes:])
1153 break
1155 def _write_send(self):
1156 assert self._buffer, 'Data should not be empty'
1157 if self._conn_lost: 1157 ↛ 1158line 1157 didn't jump to line 1158 because the condition on line 1157 was never true
1158 return
1159 try:
1160 buffer = self._buffer.popleft()
1161 n = self._sock.send(buffer)
1162 if n != len(buffer):
1163 # Not all data was written
1164 self._buffer.appendleft(buffer[n:])
1165 self._buffer_size -= n
1166 except (BlockingIOError, InterruptedError):
1167 self._buffer.appendleft(buffer)
1168 return
1169 except (SystemExit, KeyboardInterrupt):
1170 raise
1171 except BaseException as exc:
1172 self._loop._remove_writer(self._sock_fd)
1173 self._buffer.clear()
1174 self._buffer_size = 0
1175 self._fatal_error(exc, 'Fatal write error on socket transport')
1176 if self._empty_waiter is not None: 1176 ↛ 1177line 1176 didn't jump to line 1177 because the condition on line 1176 was never true
1177 self._empty_waiter.set_exception(exc)
1178 else:
1179 self._maybe_resume_protocol() # May append to buffer.
1180 if not self._buffer:
1181 self._loop._remove_writer(self._sock_fd)
1182 if self._empty_waiter is not None: 1182 ↛ 1183line 1182 didn't jump to line 1183 because the condition on line 1182 was never true
1183 self._empty_waiter.set_result(None)
1184 # gh-156512: don't let _call_connection_lost be called twice
1185 if self._closing and not self._conn_lost:
1186 self._conn_lost += 1
1187 self._call_connection_lost(None)
1188 elif self._eof:
1189 self._sock.shutdown(socket.SHUT_WR)
1191 def write_eof(self):
1192 if self._closing or self._eof:
1193 return
1194 self._eof = True
1195 if not self._buffer:
1196 self._sock.shutdown(socket.SHUT_WR)
1198 def writelines(self, list_of_data):
1199 if self._eof: 1199 ↛ 1200line 1199 didn't jump to line 1200 because the condition on line 1199 was never true
1200 raise RuntimeError('Cannot call writelines() after write_eof()')
1201 if self._empty_waiter is not None: 1201 ↛ 1202line 1201 didn't jump to line 1202 because the condition on line 1201 was never true
1202 raise RuntimeError('unable to writelines; sendfile is in progress')
1203 if not list_of_data: 1203 ↛ 1204line 1203 didn't jump to line 1204 because the condition on line 1203 was never true
1204 return
1206 if self._conn_lost:
1207 if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES: 1207 ↛ 1208line 1207 didn't jump to line 1208 because the condition on line 1207 was never true
1208 logger.warning('socket.send() raised exception.')
1209 self._conn_lost += 1
1210 return
1212 for data in list_of_data:
1213 # gh-155888: an empty chunk can never be drained, so never buffer it
1214 if not data:
1215 continue
1216 self._buffer.append(memoryview(data))
1217 self._buffer_size += len(data)
1218 if not self._buffer: 1218 ↛ 1219line 1218 didn't jump to line 1219 because the condition on line 1218 was never true
1219 return
1220 self._write_ready()
1221 # If the entire buffer couldn't be written, register a write handler
1222 if self._buffer:
1223 self._add_writer(self._sock_fd, self._write_ready)
1224 self._maybe_pause_protocol()
1226 def can_write_eof(self):
1227 return True
1229 def _call_connection_lost(self, exc):
1230 try:
1231 super()._call_connection_lost(exc)
1232 finally:
1233 self._write_ready = None
1234 self._read_ready_cb = None
1235 if self._empty_waiter is not None: 1235 ↛ 1236line 1235 didn't jump to line 1236 because the condition on line 1235 was never true
1236 self._empty_waiter.set_exception(
1237 ConnectionError("Connection is closed by peer"))
1239 def _make_empty_waiter(self):
1240 if self._empty_waiter is not None: 1240 ↛ 1241line 1240 didn't jump to line 1241 because the condition on line 1240 was never true
1241 raise RuntimeError("Empty waiter is already set")
1242 self._empty_waiter = self._loop.create_future()
1243 if not self._buffer:
1244 self._empty_waiter.set_result(None)
1245 return self._empty_waiter
1247 def _reset_empty_waiter(self):
1248 self._empty_waiter = None
1250 def close(self):
1251 self._read_ready_cb = None
1252 super().close()
1255class _SelectorDatagramTransport(_SelectorTransport, transports.DatagramTransport):
1257 _header_size = 8
1259 def __init__(self, loop, sock, protocol, address=None,
1260 waiter=None, extra=None):
1261 super().__init__(loop, sock, protocol, extra)
1262 self._address = address
1263 self._buffer_size = 0
1264 self._call_soon(self._protocol.connection_made, self)
1265 # only start reading when connection_made() has been called
1266 self._call_soon(self._add_reader, self._sock_fd, self._read_ready)
1267 if waiter is not None:
1268 # only wake up the waiter when connection_made() has been called
1269 self._call_soon(futures._set_result_unless_cancelled, waiter, None)
1271 def get_write_buffer_size(self):
1272 return self._buffer_size
1274 def _read_ready(self):
1275 if self._conn_lost: 1275 ↛ 1276line 1275 didn't jump to line 1276 because the condition on line 1275 was never true
1276 return
1277 try:
1278 data, addr = self._sock.recvfrom(self.max_size)
1279 except (BlockingIOError, InterruptedError):
1280 pass
1281 except OSError as exc:
1282 self._protocol.error_received(exc)
1283 except (SystemExit, KeyboardInterrupt):
1284 raise
1285 except BaseException as exc:
1286 self._fatal_error(exc, 'Fatal read error on datagram transport')
1287 else:
1288 self._protocol.datagram_received(data, addr)
1290 def sendto(self, data, addr=None):
1291 if not isinstance(data, (bytes, bytearray, memoryview)):
1292 raise TypeError(f'data argument must be a bytes-like object, '
1293 f'not {type(data).__name__!r}')
1295 if self._address:
1296 if addr not in (None, self._address):
1297 raise ValueError(
1298 f'Invalid address: must be None or {self._address}')
1299 addr = self._address
1301 if self._conn_lost and self._address:
1302 if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
1303 logger.warning('socket.send() raised exception.')
1304 self._conn_lost += 1
1305 return
1307 if not self._buffer:
1308 # Attempt to send it right away first.
1309 try:
1310 if self._extra['peername']:
1311 self._sock.send(data)
1312 else:
1313 self._sock.sendto(data, addr)
1314 return
1315 except (BlockingIOError, InterruptedError):
1316 self._add_writer(self._sock_fd, self._sendto_ready)
1317 except OSError as exc:
1318 self._protocol.error_received(exc)
1319 return
1320 except (SystemExit, KeyboardInterrupt):
1321 raise
1322 except BaseException as exc:
1323 self._fatal_error(
1324 exc, 'Fatal write error on datagram transport')
1325 return
1327 # Ensure that what we buffer is immutable.
1328 self._buffer.append((bytes(data), addr))
1329 self._buffer_size += len(data) + self._header_size
1330 self._maybe_pause_protocol()
1332 def _sendto_ready(self):
1333 while self._buffer:
1334 data, addr = self._buffer.popleft()
1335 self._buffer_size -= len(data) + self._header_size
1336 try:
1337 if self._extra['peername']:
1338 self._sock.send(data)
1339 else:
1340 self._sock.sendto(data, addr)
1341 except (BlockingIOError, InterruptedError):
1342 self._buffer.appendleft((data, addr)) # Try again later.
1343 self._buffer_size += len(data) + self._header_size
1344 break
1345 except OSError as exc:
1346 self._protocol.error_received(exc)
1347 return
1348 except (SystemExit, KeyboardInterrupt):
1349 raise
1350 except BaseException as exc:
1351 self._fatal_error(
1352 exc, 'Fatal write error on datagram transport')
1353 return
1355 self._maybe_resume_protocol() # May append to buffer.
1356 if not self._buffer:
1357 self._loop._remove_writer(self._sock_fd)
1358 if self._closing:
1359 self._call_connection_lost(None)