FM / aiohttp

/opt/cloudlinux/venv/lib/python3.11/site-packages/aiohttp/

/opt/cloudlinux/venv/lib/python3.11/site-packages/aiohttp

Name	Size	Mode	Actions
.hash/	-	0755	rm
__pycache__/	-	0755	rm
abc.py	5500	0644	edit dl rm
base_protocol.py	2741	0644	edit dl rm
client.py	47276	0644	edit dl rm
client_exceptions.py	9411	0644	edit dl rm
client_proto.py	8651	0644	edit dl rm
client_reqrep.py	39680	0644	edit dl rm
client_ws.py	11010	0644	edit dl rm
compression_utils.py	5015	0644	edit dl rm
connector.py	52798	0644	edit dl rm
cookiejar.py	14015	0644	edit dl rm
formdata.py	6106	0644	edit dl rm
hdrs.py	4613	0644	edit dl rm
helpers.py	30255	0644	edit dl rm
http.py	1842	0644	edit dl rm
http_exceptions.py	2716	0644	edit dl rm
http_parser.py	35496	0644	edit dl rm
http_websocket.py	26716	0644	edit dl rm
http_writer.py	5933	0644	edit dl rm
locks.py	1136	0644	edit dl rm
log.py	325	0644	edit dl rm
multipart.py	32472	0644	edit dl rm
payload.py	13542	0644	edit dl rm
payload_streamer.py	2087	0644	edit dl rm
py.typed	7	0644	edit dl rm
pytest_plugin.py	11605	0644	edit dl rm
resolver.py	5070	0644	edit dl rm
streams.py	20836	0644	edit dl rm
tcp_helpers.py	961	0644	edit dl rm
test_utils.py	20185	0644	edit dl rm
tracing.py	15132	0644	edit dl rm
typedefs.py	1471	0644	edit dl rm
web.py	19263	0644	edit dl rm
web_app.py	18311	0644	edit dl rm
web_exceptions.py	10360	0644	edit dl rm
web_fileresponse.py	11416	0644	edit dl rm
web_log.py	7801	0644	edit dl rm
web_middlewares.py	4032	0644	edit dl rm
web_protocol.py	23044	0644	edit dl rm
web_request.py	28756	0644	edit dl rm
web_response.py	27729	0644	edit dl rm
web_routedef.py	6132	0644	edit dl rm
web_runner.py	11736	0644	edit dl rm
web_server.py	2587	0644	edit dl rm
web_urldispatcher.py	40057	0644	edit dl rm
web_ws.py	18647	0644	edit dl rm
worker.py	7965	0644	edit dl rm
_cparser.pxd	4318	0644	edit dl rm
_find_header.pxd	68	0644	edit dl rm
_headers.pxi	2007	0644	edit dl rm
_helpers.cpython-311-x86_64-linux-gnu.so	310476	0755	edit dl rm
_helpers.pyi	202	0644	edit dl rm
_helpers.pyx	1049	0644	edit dl rm
_http_parser.cpython-311-x86_64-linux-gnu.so	1889106	0755	edit dl rm
_http_parser.pyx	28058	0644	edit dl rm
_http_writer.cpython-311-x86_64-linux-gnu.so	320845	0755	edit dl rm
_http_writer.pyx	4575	0644	edit dl rm
_websocket.cpython-311-x86_64-linux-gnu.so	187629	0755	edit dl rm
_websocket.pyx	1561	0644	edit dl rm
__init__.py	7762	0644	edit dl rm

Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/aiohttp/worker.py (7965B)

"""Async gunicorn worker for aiohttp.web"""

import asyncio
import os
import re
import signal
import sys
from types import FrameType
from typing import Any, Awaitable, Callable, Optional, Union  # noqa

from gunicorn.config import AccessLogFormat as GunicornAccessLogFormat
from gunicorn.workers import base

from aiohttp import web

from .helpers import set_result
from .web_app import Application
from .web_log import AccessLogger

try:
    import ssl

SSLContext = ssl.SSLContext
except ImportError:  # pragma: no cover
    ssl = None  # type: ignore[assignment]
    SSLContext = object  # type: ignore[misc,assignment]

__all__ = ("GunicornWebWorker", "GunicornUVLoopWebWorker")

class GunicornWebWorker(base.Worker):  # type: ignore[misc,no-any-unimported]

DEFAULT_AIOHTTP_LOG_FORMAT = AccessLogger.LOG_FORMAT
    DEFAULT_GUNICORN_LOG_FORMAT = GunicornAccessLogFormat.default

def __init__(self, *args: Any, **kw: Any) -> None:  # pragma: no cover
        super().__init__(*args, **kw)

self._task: Optional[asyncio.Task[None]] = None
        self.exit_code = 0
        self._notify_waiter: Optional[asyncio.Future[bool]] = None

def init_process(self) -> None:
        # create new event_loop after fork
        asyncio.get_event_loop().close()

self.loop = asyncio.new_event_loop()
        asyncio.set_event_loop(self.loop)

super().init_process()

def run(self) -> None:
        self._task = self.loop.create_task(self._run())

try:  # ignore all finalization problems
            self.loop.run_until_complete(self._task)
        except Exception:
            self.log.exception("Exception in gunicorn worker")
        self.loop.run_until_complete(self.loop.shutdown_asyncgens())
        self.loop.close()

sys.exit(self.exit_code)

async def _run(self) -> None:
        runner = None
        if isinstance(self.wsgi, Application):
            app = self.wsgi
        elif asyncio.iscoroutinefunction(self.wsgi):
            wsgi = await self.wsgi()
            if isinstance(wsgi, web.AppRunner):
                runner = wsgi
                app = runner.app
            else:
                app = wsgi
        else:
            raise RuntimeError(
                "wsgi app should be either Application or "
                "async function returning Application, got {}".format(self.wsgi)
            )

if runner is None:
            access_log = self.log.access_log if self.cfg.accesslog else None
            runner = web.AppRunner(
                app,
                logger=self.log,
                keepalive_timeout=self.cfg.keepalive,
                access_log=access_log,
                access_log_format=self._get_valid_log_format(
                    self.cfg.access_log_format
                ),
                shutdown_timeout=self.cfg.graceful_timeout / 100 * 95,
            )
        await runner.setup()

ctx = self._create_ssl_context(self.cfg) if self.cfg.is_ssl else None

runner = runner
        assert runner is not None
        server = runner.server
        assert server is not None
        for sock in self.sockets:
            site = web.SockSite(
                runner,
                sock,
                ssl_context=ctx,
            )
            await site.start()

# If our parent changed then we shut down.
        pid = os.getpid()
        try:
            while self.alive:  # type: ignore[has-type]
                self.notify()

cnt = server.requests_count
                if self.max_requests and cnt > self.max_requests:
                    self.alive = False
                    self.log.info("Max requests, shutting down: %s", self)

elif pid == os.getpid() and self.ppid != os.getppid():
                    self.alive = False
                    self.log.info("Parent changed, shutting down: %s", self)
                else:
                    await self._wait_next_notify()
        except BaseException:
            pass

await runner.cleanup()

def _wait_next_notify(self) -> "asyncio.Future[bool]":
        self._notify_waiter_done()

loop = self.loop
        assert loop is not None
        self._notify_waiter = waiter = loop.create_future()
        self.loop.call_later(1.0, self._notify_waiter_done, waiter)

return waiter

def _notify_waiter_done(
        self, waiter: Optional["asyncio.Future[bool]"] = None
    ) -> None:
        if waiter is None:
            waiter = self._notify_waiter
        if waiter is not None:
            set_result(waiter, True)

if waiter is self._notify_waiter:
            self._notify_waiter = None

def init_signals(self) -> None:
        # Set up signals through the event loop API.

self.loop.add_signal_handler(
            signal.SIGQUIT, self.handle_quit, signal.SIGQUIT, None
        )

self.loop.add_signal_handler(
            signal.SIGTERM, self.handle_exit, signal.SIGTERM, None
        )

self.loop.add_signal_handler(
            signal.SIGINT, self.handle_quit, signal.SIGINT, None
        )

self.loop.add_signal_handler(
            signal.SIGWINCH, self.handle_winch, signal.SIGWINCH, None
        )

self.loop.add_signal_handler(
            signal.SIGUSR1, self.handle_usr1, signal.SIGUSR1, None
        )

self.loop.add_signal_handler(
            signal.SIGABRT, self.handle_abort, signal.SIGABRT, None
        )

# Don't let SIGTERM and SIGUSR1 disturb active requests
        # by interrupting system calls
        signal.siginterrupt(signal.SIGTERM, False)
        signal.siginterrupt(signal.SIGUSR1, False)
        # Reset signals so Gunicorn doesn't swallow subprocess return codes
        # See: https://github.com/aio-libs/aiohttp/issues/6130

def handle_quit(self, sig: int, frame: Optional[FrameType]) -> None:
        self.alive = False

# worker_int callback
        self.cfg.worker_int(self)

# wakeup closing process
        self._notify_waiter_done()

def handle_abort(self, sig: int, frame: Optional[FrameType]) -> None:
        self.alive = False
        self.exit_code = 1
        self.cfg.worker_abort(self)
        sys.exit(1)

@staticmethod
    def _create_ssl_context(cfg: Any) -> "SSLContext":
        """Creates SSLContext instance for usage in asyncio.create_server.

See ssl.SSLSocket.__init__ for more details.
        """
        if ssl is None:  # pragma: no cover
            raise RuntimeError("SSL is not supported.")

ctx = ssl.SSLContext(cfg.ssl_version)
        ctx.load_cert_chain(cfg.certfile, cfg.keyfile)
        ctx.verify_mode = cfg.cert_reqs
        if cfg.ca_certs:
            ctx.load_verify_locations(cfg.ca_certs)
        if cfg.ciphers:
            ctx.set_ciphers(cfg.ciphers)
        return ctx

def _get_valid_log_format(self, source_format: str) -> str:
        if source_format == self.DEFAULT_GUNICORN_LOG_FORMAT:
            return self.DEFAULT_AIOHTTP_LOG_FORMAT
        elif re.search(r"%\([^\)]+\)", source_format):
            raise ValueError(
                "Gunicorn's style options in form of `%(name)s` are not "
                "supported for the log formatting. Please use aiohttp's "
                "format specification to configure access log formatting: "
                "http://docs.aiohttp.org/en/stable/logging.html"
                "#format-specification"
            )
        else:
            return source_format

class GunicornUVLoopWebWorker(GunicornWebWorker):
    def init_process(self) -> None:
        import uvloop

# Close any existing event loop before setting a
        # new policy.
        asyncio.get_event_loop().close()

# Setup uvloop policy, so that every
        # asyncio.get_event_loop() will create an instance
        # of uvloop event loop.
        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

super().init_process()

cmd: