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
