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

1"""Event loop using a selector and related classes. 

2 

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""" 

6 

7__all__ = 'BaseSelectorEventLoop', 

8 

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 

22 

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 

32 

33_HAS_SENDMSG = hasattr(socket.socket, 'sendmsg') 

34 

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 

41 

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) 

51 

52 

53class BaseSelectorEventLoop(base_events.BaseEventLoop): 

54 """Selector event loop. 

55 

56 See events.AbstractEventLoop for API specification. 

57 """ 

58 

59 def __init__(self, selector=None): 

60 super().__init__() 

61 

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() 

68 

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) 

74 

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 

93 

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) 

99 

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 

110 

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 

118 

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) 

126 

127 def _process_self_data(self, data): 

128 pass 

129 

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 

141 

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 

151 

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) 

159 

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) 

167 

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) 

219 

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) 

245 

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. 

256 

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) 

273 

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}') 

287 

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 

302 

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)) 

315 

316 if reader is not None: 

317 reader.cancel() 

318 return True 

319 else: 

320 return False 

321 

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 

336 

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)) 

351 

352 if writer is not None: 

353 writer.cancel() 

354 return True 

355 else: 

356 return False 

357 

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) 

362 

363 def remove_reader(self, fd): 

364 """Remove a reader callback.""" 

365 self._ensure_fd_no_transport(fd) 

366 return self._remove_reader(fd) 

367 

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) 

372 

373 def remove_writer(self, fd): 

374 """Remove a writer callback.""" 

375 self._ensure_fd_no_transport(fd) 

376 return self._remove_writer(fd) 

377 

378 async def sock_recv(self, sock, n): 

379 """Receive data from the socket. 

380 

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 

399 

400 def _sock_read_done(self, fd, fut, handle=None): 

401 if handle is None or not handle.cancelled(): 

402 self.remove_reader(fd) 

403 

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) 

419 

420 async def sock_recv_into(self, sock, buf): 

421 """Receive data from the socket. 

422 

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 

440 

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) 

457 

458 async def sock_recvfrom(self, sock, bufsize): 

459 """Receive a datagram from a datagram socket. 

460 

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 

480 

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) 

497 

498 async def sock_recvfrom_into(self, sock, buf, nbytes=0): 

499 """Receive data from the socket. 

500 

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) 

509 

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 

522 

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) 

539 

540 async def sock_sendall(self, sock, data): 

541 """Send data to the socket. 

542 

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 

557 

558 if n == len(data): 

559 # all data sent 

560 return 

561 

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 

571 

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 

586 

587 start += n 

588 

589 if start == len(view): 

590 fut.set_result(None) 

591 else: 

592 pos[0] = start 

593 

594 async def sock_sendto(self, sock, data, address): 

595 """Send a datagram from sock to address. 

596 

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 

607 

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 

617 

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) 

632 

633 async def sock_connect(self, sock, address): 

634 """Connect to a remote socket at address. 

635 

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") 

641 

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] 

649 

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 

657 

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 

680 

681 def _sock_write_done(self, fd, fut, handle=None): 

682 if handle is None or not handle.cancelled(): 

683 self.remove_writer(fd) 

684 

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 

688 

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 

705 

706 async def sock_accept(self, sock): 

707 """Accept a connection. 

708 

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 

721 

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)) 

741 

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 

755 

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) 

769 

770 def _stop_serving(self, sock): 

771 self._remove_reader(sock.fileno()) 

772 sock.close() 

773 

774 

775class _SelectorTransport(transports._FlowControlMixin, 

776 transports.Transport): 

777 

778 max_size = 256 * 1024 # Buffer size passed to recv(). 

779 

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 

784 

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) 

802 

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 

809 

810 if self._server is not None: 

811 self._server._attach(self) 

812 loop._transports[self._sock_fd] = self 

813 

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') 

829 

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' 

837 

838 bufsize = self.get_write_buffer_size() 

839 info.append(f'write=<{state}, bufsize={bufsize}>') 

840 return '<{}>'.format(' '.join(info)) 

841 

842 def abort(self): 

843 self._force_close(None) 

844 

845 def set_protocol(self, protocol): 

846 self._protocol = protocol 

847 self._protocol_connected = True 

848 

849 def get_protocol(self): 

850 return self._protocol 

851 

852 def is_closing(self): 

853 return self._closing 

854 

855 def is_reading(self): 

856 return not self.is_closing() and not self._paused 

857 

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) 

865 

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) 

873 

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) 

883 

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) 

890 

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) 

904 

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) 

917 

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 

931 

932 def get_write_buffer_size(self): 

933 return self._buffer_size 

934 

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) 

939 

940 def _add_writer(self, fd, callback, *args): 

941 self._loop._add_writer(fd, callback, *args, context=self._context) 

942 

943 def _call_soon(self, callback, *args): 

944 self._loop.call_soon(callback, *args, context=self._context) 

945 

946class _SelectorSocketTransport(_SelectorTransport): 

947 

948 _start_tls_compatible = True 

949 _sendfile_compatible = constants._SendfileMode.TRY_NATIVE 

950 

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) 

965 

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) 

972 

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 

978 

979 super().set_protocol(protocol) 

980 

981 def _read_ready(self): 

982 self._read_ready_cb() 

983 

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 

987 

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 

998 

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 

1008 

1009 if not nbytes: 

1010 self._read_ready__on_eof() 

1011 return 

1012 

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.') 

1020 

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 

1033 

1034 if not data: 

1035 self._read_ready__on_eof() 

1036 return 

1037 

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.') 

1045 

1046 def _read_ready__on_eof(self): 

1047 if self._loop.get_debug(): 

1048 logger.debug("%r received EOF", self) 

1049 

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 

1058 

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() 

1066 

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 

1077 

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 

1083 

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) 

1101 

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() 

1108 

1109 def _get_sendmsg_buffer(self): 

1110 return itertools.islice(self._buffer, SC_IOV_MAX) 

1111 

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) 

1142 

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 

1154 

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) 

1190 

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) 

1197 

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 

1205 

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 

1211 

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() 

1225 

1226 def can_write_eof(self): 

1227 return True 

1228 

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")) 

1238 

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 

1246 

1247 def _reset_empty_waiter(self): 

1248 self._empty_waiter = None 

1249 

1250 def close(self): 

1251 self._read_ready_cb = None 

1252 super().close() 

1253 

1254 

1255class _SelectorDatagramTransport(_SelectorTransport, transports.DatagramTransport): 

1256 

1257 _header_size = 8 

1258 

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) 

1270 

1271 def get_write_buffer_size(self): 

1272 return self._buffer_size 

1273 

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) 

1289 

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}') 

1294 

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 

1300 

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 

1306 

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 

1326 

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() 

1331 

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 

1354 

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)