class UvicornThread(threading.Thread): def __init__(self, application, host, port): super().__init__() self.host = host self.port = port self.application = application self.server = None @override_settings(DEBUG=True) def run(self): self.loop = asyncio.new_event_loop() config = UvicornConfig(self.application, host=self.host, port=self.port) self.server = Uvicorn(config) self.server.install_signal_handlers = lambda *args, **kwargs: None self.loop.run_until_complete(self.server.serve()) self.server = None @property def started(self): return self.server and self.server.started def terminate(self): self.server.force_exit = True self.server.should_exit = True self.loop.create_task(self.server.shutdown())
def run(self): self.config.app = self.wsgi server = Server(config=self.config) loop = asyncio.get_event_loop() loop.run_until_complete( server.serve(sockets=self.sockets, shutdown_servers=False) )
async def server(): config = Config(app=app, lifespan="off") server = Server(config=config) task = asyncio.ensure_future(server.serve()) try: while not server.started: await asyncio.sleep(0.0001) yield server finally: task.cancel()
def run(self) -> None: self.config.app = self.wsgi server = Server(config=self.config) loop = asyncio.get_event_loop() loop.run_until_complete(server.serve(sockets=self.sockets)) # Exit with status 3 when worker starts failed, so Gunicorn # can shut it down to avoid infinite start/stop cycles. # See: https://github.com/encode/uvicorn/issues/1066 if not server.started: sys.exit(Arbiter.WORKER_BOOT_ERROR)
async def https_server(cert_and_key_paths): cert_path, key_path = cert_and_key_paths config = Config(app=app, lifespan="off", ssl_certfile=cert_path, ssl_keyfile=key_path, port=8001) server = Server(config=config) task = asyncio.ensure_future(server.serve()) try: while not server.started: await asyncio.sleep(0.0001) yield server finally: server.should_exit = True await task
async def https_server(cert_pem_file, cert_private_key_file): config = Config( app=app, lifespan="off", ssl_certfile=cert_pem_file, ssl_keyfile=cert_private_key_file, port=8001, ) server = Server(config=config) task = asyncio.ensure_future(server.serve()) try: while not server.started: await asyncio.sleep(0.0001) yield server finally: server.should_exit = True await task
from uvicorn.main import Config, Server from .app import app from .models import KVContainer from .utils import strtobool debug = strtobool(os.environ.get("DEBUG")) access_log = strtobool(os.environ.get("ACCESS_LOG"), True) host = os.environ.get("HOST", "0.0.0.0") port = int(os.environ.get("PORT", "80")) app._vtubers = KVContainer(app.credentials.get("vtubers_storage"), "vtubers") app._configs = KVContainer(app.credentials.get("configs_storage"), "configs") app._states = KVContainer(app.credentials.get("plugins_storage"), "states") plugin_dir = path.join(path.dirname(path.abspath(__file__)), "plugins") plugins_path = [file[:-3] for file in os.listdir(plugin_dir) if file.endswith(".py")] plugins = {plugin.__name__: plugin for plugin in [importlib.import_module(f"pystargazer.plugins.{plugin_path}") for plugin_path in plugins_path]} if not debug: logging.getLogger("apscheduler").setLevel(logging.WARNING) app.scheduler.start() app.init_starlette(debug) config = Config(app.starlette, host=host, port=port, lifespan="on", access_log=access_log) server = Server(config) # noinspection PyProtectedMember app.loop.run_until_complete(server.serve())
def run(self) -> None: self.config.app = self.wsgi server = Server(config=self.config) loop = asyncio.get_event_loop() loop.run_until_complete(server.serve(sockets=self.sockets))
class UvicornWorker(Worker): """ A worker class for Gunicorn that interfaces with an ASGI consumer callable, rather than a WSGI callable. """ CONFIG_KWARGS = {"loop": "uvloop", "http": "httptools"} def __init__(self, *args, **kwargs): super(UvicornWorker, self).__init__(*args, **kwargs) logger = logging.getLogger("uvicorn.error") logger.handlers = self.log.error_log.handlers logger.setLevel(self.log.error_log.level) logger.propagate = False logger = logging.getLogger("uvicorn.access") logger.handlers = self.log.access_log.handlers logger.setLevel(self.log.access_log.level) logger.propagate = False config_kwargs = { "app": None, "log_config": None, "timeout_keep_alive": self.cfg.keepalive, "timeout_notify": self.timeout, "callback_notify": self.callback_notify, "limit_max_requests": self.max_requests, "forwarded_allow_ips": self.cfg.forwarded_allow_ips, } if self.cfg.is_ssl: ssl_kwargs = { "ssl_keyfile": self.cfg.ssl_options.get("keyfile"), "ssl_certfile": self.cfg.ssl_options.get("certfile"), "ssl_version": self.cfg.ssl_options.get("ssl_version"), "ssl_cert_reqs": self.cfg.ssl_options.get("cert_reqs"), "ssl_ca_certs": self.cfg.ssl_options.get("ca_certs"), "ssl_ciphers": self.cfg.ssl_options.get("ciphers"), } config_kwargs.update(ssl_kwargs) if self.cfg.settings["backlog"].value: config_kwargs["backlog"] = self.cfg.settings["backlog"].value config_kwargs.update(self.CONFIG_KWARGS) self.config = Config(**config_kwargs) def init_process(self): self.config.setup_event_loop() super(UvicornWorker, self).init_process() def init_signals(self): pass def run(self): self.config.app = self.wsgi self.server = Server(config=self.config) asyncio.ensure_future(self.watchdog()) loop = asyncio.get_event_loop() loop.run_until_complete(self.server.serve(sockets=self.sockets)) async def callback_notify(self): self.notify() async def watchdog(self): while self.alive: await asyncio.sleep(1) if self.ppid != os.getppid(): self.log.info("Parent changed, shutting down: %s", self) self.alive = False if not self.alive: self.server.should_exit = True