Method conn_handler

src/websockets/asyncio/server.py:343–395

Handle the lifecycle of a WebSocket connection. Since this method doesn't have a caller that can handle exceptions, it attempts to log relevant ones. It guarantees that the TCP connection is closed before exiting.

(self, connection: ServerConnection)

            self.logger.info("server listening on %s", name)

    async def conn_handler(self, connection: ServerConnection) -> None:
        """
        Handle the lifecycle of a WebSocket connection.

        Since this method doesn't have a caller that can handle exceptions,
        it attempts to log relevant ones.

        It guarantees that the TCP connection is closed before exiting.

        """
        try:
            async with asyncio_timeout(self.open_timeout):
                try:
                    await connection.handshake(
                        self.process_request,
                        self.process_response,
                        self.server_header,
                    )
                except asyncio.CancelledError:
                    connection.transport.abort()
                    raise
                except Exception:
                    connection.logger.error("opening handshake failed", exc_info=True)
                    connection.transport.abort()
                    return

            if connection.protocol.state is not OPEN:
                # process_request or process_response rejected the handshake.
                connection.transport.abort()
                return

            try:
                connection.start_keepalive()
                await self.handler(connection)
            except Exception:
                connection.logger.error("connection handler failed", exc_info=True)
                await connection.close(CloseCode.INTERNAL_ERROR)
            else:
                await connection.close()

        except TimeoutError:
            # When the opening handshake times out, there's nothing to log.
            pass

        except Exception:  # pragma: no cover
            # Don't leak connections on unexpected errors.
            connection.transport.abort()

        finally:
            # Registration is tied to the lifecycle of conn_handler() because
            # the server waits for connection handlers to terminate, even if
            # all connections are already closed.
            del self.handlers[connection]

    def start_connection_handler(self, connection: ServerConnection) -> None:
        """