24499344_第八十三章 转变

admin

        self._connection: AsyncConnectionInterface | None = None
        self._connect_failed = False

    async def handle_async_request(self, request: Request) -> Response:
        timeouts = request.extensions.get("timeout", {})
        sni_hostname = request.extensions.get("sni_hostname", None)
        timeout = timeouts.get("connect", None)

        async with self._connect_lock:
            if self._connection is None:
                try:
                    # Connect to the proxy
                    kwargs = {
                        "host": self._proxy_origin.host.decode("ascii"),
                        "port": self._proxy_origin.port,
                        "timeout": timeout,
                    }
                    async with Trace("connect_tcp", logger, request, kwargs) as trace:
                        stream = await self._network_backend.connect_tcp(**kwargs)
                        trace.return_value = stream

                    # Connect to the remote host using socks5
                    kwargs = {
                        "stream": stream,
                        "host": self._remote_origin.host.decode("ascii"),
                        "port": self._remote_origin.port,
                        "auth": self._proxy_auth,
                    }
                    async with Trace(
                        "setup_socks5_connection", logger, request, kwargs
                    ) as trace:
                        await _init_socks5_connection(**kwargs)
                        trace.return_value = stream

                    # Upgrade the stream to SSL
                    if self._remote_origin.scheme == b"https":
                        ssl_context = (
                            default_ssl_context()
                            if self._ssl_context is None
                            else self._ssl_context
                        )
                        alpn_protocols = (
                            ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
                        )
                        ssl_context.set_alpn_protocols(alpn_protocols)

                        kwargs = {
                            "ssl_context": ssl_context,
                            "server_hostname": sni_hostname
                            or self._remote_origin.host.decode("ascii"),
                            "timeout": timeout,
                        }
                        async with Trace("start_tls", logger, request, kwargs) as trace:
                            stream = await stream.start_tls(**kwargs)
                            trace.return_value = stream

                    # Determine if we should be using HTTP/1.1 or HTTP/2
                    ssl_object = stream.get_extra_info("ssl_object")
                    http2_negotiated = (
                        ssl_object is not None
                        and ssl_object.selected_alpn_protocol() == "h2"
                    )

                    # Create the HTTP/1.1 or HTTP/2 connection
                    if http2_negotiated or (
                        self._http2 and not self._http1
                    ):  # pragma: nocover
                        from .http2 import AsyncHTTP2Connection

                        self._connection = AsyncHTTP2Connection(
                            origin=self._remote_origin,
                            stream=stream,
                            keepalive_expiry=self._keepalive_expiry,
                        )
                    else:
                        self._connection = AsyncHTTP11Connection(
                            origin=self._remote_origin,
                            stream=stream,
                            keepalive_expiry=self._keepalive_expiry,
                        )
                except Exception as exc:
                    self._connect_failed = True
                    raise exc
            elif not self._connection.is_available():  # pragma: nocover
                raise ConnectionNotAvailable()

        return await self._connection.handle_async_request(request)

    def can_handle_request(self, origin: Origin) -> bool:
        return origin == self._remote_origin

    async def aclose(self) -> None:
        if self._connection is not None:
            await self._connection.aclose()

    def is_available(self) -> bool:
        if self._connection is None:  # pragma: nocover
            # If HTTP/2 support is enabled, and the resulting connection could
            # end up as HTTP/2 then we should indicate the connection as being
            # available to service multiple requests.
            return (
                self._http2
                and (self._remote_origin.scheme == b"https" or not self._http1)
                and not self._connect_failed
            )
        return self._connection.is_available()

    def has_expired(self) -> bool:
        if self._connection is None:  # pragma: nocover
            return self._connect_failed
        return self._connection.has_expired()

    def is_idle(self) -> bool:
        if self._connection is None:  # pragma: nocover
            return self._connect_failed
        return self._connection.is_idle()

    def is_closed(self) -> bool:
        if self._connection is None:  # pragma: nocover
            return self._connect_failed
        return self._connection.is_closed()

    def info(self) -> str:
        if self._connection is None:  # pragma: nocover
            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
        return self._connection.info()

    def __repr__(self) -> str:
        return f"<{self.__class__.__name__} [{self.info()}]>"
不是怕独孤博这个人，更不担心独孤博真的会杀了他。
虽然众人都知道唐三和大师的关系，但石墨方才分析时还是刻意没有提起他们，毕竟他们也都知道玉天恒和那位大师的关系，即使现在玉天恒不在，但该回避的还是要回避的。
……
“弗兰德，你当时不该那么快就离开的”，史莱克一行人离开天斗皇家学院，玉小刚忍不住道，他当时主动说“我们滚”，而不是“我们走”，也是有激三位教委出手的想法。
“即使我们能留下来，以后也一定会遭到那个雪星亲王的针对，还不如离开”，弗兰德无奈解释。
“三位教委已经决定禀明皇帝，有皇帝的命令，那雪星亲王在跋扈，也不可能公然针对我们，等以后进入教委会，他也只能回避，而且这些孩子还要参加魂师大赛，我们这些老师暂时受些委屈，也没什么问题”。
玉小刚还是有些不甘心，如果加入天斗皇家学院，并组建新战队，他在这一届魂师大赛就能向全大陆展示自己的成果。
大师说的这些，弗兰德也不是没想过，真正让他决定离开的，是他看到即使身为魂斗罗级别的教委，也必须看一个皇室混蛋亲王的脸色。
至于孩子们参加魂师大赛的问题，他其实早就有了解决办法，这些年玉小刚没和柳二龙通过书信，但他可是一直保持着联系，知道柳二龙就在天斗城的蓝霸学院，以前他就想过投奔柳二龙，但那个时候只有他自己过去难免尴尬，而且过去后自己最多当个副院长，现在有玉小刚在，二龙一定会想尽一切办法留下玉小刚，甚至把蓝霸学院更名为史莱克学院也不是不可能。
“难得来一次，我们就带孩子们在天斗城转转，看能不能碰到什么加盟其他学院机会，以我们几个的实力，孩子们又这么优秀，害怕其他没个落脚的地方吗”，弗兰德显得非常乐观。
玉小刚想了想from __future__ import annota