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)
)
def start_uvicorn():
config = Config(app=app,
host="0.0.0.0",
loop="asyncio",
log_level=logger.level)
server = Server(config=config)
server.run()
def run(self):
self.log.level = self.log.loglevel
kwargs = {
"app": self.wsgi,
"sockets": self.sockets,
"logger": self.log,
"timeout_keep_alive": self.cfg.keepalive,
"timeout_notify": self.timeout,
"callback_notify": self.callback_notify,
}
if self.cfg.is_ssl:
_ssl_opt = {
"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"),
}
kwargs.update(_ssl_opt)
kwargs.update(self.CONFIG_KWARGS)
self.config = Config(**kwargs)
self.server = Server(config=self.config)
self.server.run()
def test_run_with_shutdown():
async def app(scope, receive, send):
assert scope["type"] == "http"
while True:
time.sleep(1)
config = Config(app=app, loop="asyncio", workers=2, limit_max_requests=1)
server = Server(config=config)
sock = config.bind_socket()
exc = True
def safe_run():
nonlocal exc, server
try:
exc = None
config.setup_event_loop()
loop = asyncio.get_event_loop()
loop.run_until_complete(server.serve(sockets=[sock]))
except Exception as e:
exc = e
thread = threading.Thread(target=safe_run)
thread.start()
while not server.started:
time.sleep(0.01)
server.should_exit = True
thread.join()
assert exc is None
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 run(self):
self.log.level = self.log.loglevel
kwargs = {
"app": self.wsgi,
"sockets": self.sockets,
"logger": self.log,
"timeout_keep_alive": self.cfg.keepalive,
"timeout_notify": self.timeout,
"callback_notify": self.callback_notify,
}
kwargs.update(self.CONFIG_KWARGS)
self.config = Config(**kwargs)
self.server = Server(config=self.config)
self.server.run()
def init_signals(self):
pass
async def callback_notify(self):
self.notify()
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_server(path, container, port=None):
"""
创建一个简单的server用来测试
:param path:
:param port:
:return:
"""
try:
import asyncio
from apistellar import Application
from uvicorn.main import Server, HttpToolsProtocol
except ImportError:
warnings.warn("Python3.6: apistellar required. ")
raise
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
app = Application("test", current_dir=path)
port = port or free_port()
server = Server(app, "127.0.0.1", port, loop, None, HttpToolsProtocol)
loop.run_until_complete(server.create_server())
if server.server is not None:
container.append(port)
container.append(loop)
container.append(server.server)
loop.create_task(server.tick())
loop.run_forever()
def start_uvicorn():
config = Config(app=app,
host="0.0.0.0",
port='9000',
loop="asyncio",
log_level=logger.level)
server = Server(config=config)
logger.debug("Starting up the message queue")
server.run()
def run(
app,
host='127.0.0.1',
port=8000,
uds=None,
fd=None,
loop='auto',
proto_http='auto',
proto_ws='auto',
log_level=None,
access_log=None,
proxy_headers=False,
proxy_trust_ips=None,
limit_concurrency=None,
# limit_max_requests=None,
backlog=2048,
timeout_keep_alive=0
# timeout_notify=30
):
loop = loops.get_loop(loop)
protocol_cls_http = protocols_http.get_protocol(proto_http)
protocol_cls_ws = protocols_ws.get_protocol(proto_ws)
app.send_signal(Signals.after_loop, loop=loop)
if access_log is None:
access_log = bool(app.debug)
log_level = (LOG_LEVELS[log_level] if log_level else
(logging.DEBUG if app.debug else logging.WARNING))
if proxy_trust_ips is None:
proxy_trust_ips = os.environ.get("PROXY_TRUST_IPS", "*")
uvicorn_config = Config(
app=app,
host=host,
port=port,
uds=uds,
fd=fd,
loop=loop,
http=protocol_cls_http,
ws=protocol_cls_ws,
log_level=log_level,
access_log=access_log,
debug=bool(app.debug),
proxy_headers=proxy_headers,
forwarded_allow_ips=proxy_trust_ips,
limit_concurrency=limit_concurrency,
# limit_max_requests=limit_max_requests,
backlog=backlog,
timeout_keep_alive=timeout_keep_alive,
# timeout_notify=timeout_notify
)
server = Server(uvicorn_config)
server.run()
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)
def run(self):
self.log.level = self.log.loglevel
kwargs = {
"app": self.wsgi,
"sockets": self.sockets,
"logger": self.log,
"timeout_keep_alive": self.cfg.keepalive,
"timeout_notify": self.timeout,
"callback_notify": self.callback_notify,
}
kwargs.update(self.CONFIG_KWARGS)
self.config = Config(**kwargs)
self.server = Server(config=self.config)
self.server.run()
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
async def start_dummy_server(loop, port):
"""Start dummy server."""
host = '0.0.0.0'
config = Config(app, host=host, port=port, workers=2, log_level='warning')
server = Server(config=config)
await server.serve()
def run(
app,
host='127.0.0.1',
port=8000,
uds=None,
fd=None,
loop='auto',
proto_http='auto',
proto_ws='auto',
log_level=None,
access_log=None,
# proxy_headers=False,
limit_concurrency=None,
# limit_max_requests=None,
timeout_keep_alive=0
# timeout_notify=30
):
loop = loops.get_loop(loop)
protocol_cls_http = protocols_http.get_protocol(proto_http)
protocol_cls_ws = protocols_ws.get_protocol(proto_ws)
app.send_signal('after_loop', loop=loop)
if access_log is None:
access_log = bool(app.debug)
uvicorn_config = Config(
app=app,
host=host,
port=port,
uds=uds,
fd=fd,
loop=loop,
http=protocol_cls_http,
ws=protocol_cls_ws,
logger=_build_server_logger(app, log_level),
access_log=access_log,
debug=bool(app.debug),
limit_concurrency=limit_concurrency,
# limit_max_requests=limit_max_requests,
timeout_keep_alive=timeout_keep_alive,
# timeout_notify=timeout_notify
)
server = Server(uvicorn_config)
server.run()
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
def test_statreload(certfile_and_keyfile):
certfile, keyfile = certfile_and_keyfile
config = Config(app=None, ssl_certfile=certfile, ssl_keyfile=keyfile)
server = Server(config)
type(server).run = lambda self: None
reloader = StatReload(config)
reloader.run(server.run)
def test_run_reload():
config = Config(app=app, loop="asyncio", reload=True, limit_max_requests=1)
server = Server(config=config)
thread = threading.Thread(target=server.run)
thread.start()
while not server.started:
time.sleep(0.01)
response = requests.get("http://127.0.0.1:8000")
assert response.status_code == 204
thread.join()
def test_run(host, url):
config = Config(app=app, host=host, loop="asyncio", limit_max_requests=1)
server = Server(config=config)
thread = threading.Thread(target=server.run)
thread.start()
while not server.started:
time.sleep(0.01)
response = requests.get(url)
assert response.status_code == 204
thread.join()
def serve_in_thread(server: Server):
thread = threading.Thread(target=server.run)
thread.start()
try:
while not server.started:
time.sleep(1e-3)
yield server
finally:
server.should_exit = True
thread.join()
def server_run():
def on_tick_sync():
if not ready.is_set():
loops.append(asyncio.get_event_loop())
ready.set()
async def on_tick():
on_tick_sync()
config = Config(app, host="127.0.0.1", port=port, loop="asyncio")
config.callback_notify = on_tick
config.log_config = {"version": 1}
config.disable_lifespan = True
config.logger = logging.getLogger("uvicorn")
server = Server(config=config)
server.install_signal_handlers = lambda *args, **kwargs: None
try:
server.started.set = on_tick_sync
except Exception:
pass
server.run()
class Uvicorn(Component):
cfg: UvicornConfig
def __init__(self, cfg: UvicornConfig, fapp: FastAPI):
self.cfg = cfg
self.fapp = fapp
self._srv: Optional[Server] = None
self._loop_fut: Optional[asyncio.Future] = None
self._sockets = None
async def prepare(self) -> None:
cfg = Config(AppWrapper(self, self.fapp), **self.cfg.dict())
self._srv = Server(cfg)
async def start(self) -> None:
if self._srv is None:
raise UserWarning
config = self._srv.config
if not config.loaded:
config.load()
self._srv.lifespan = config.lifespan_class(config)
self._srv.install_signal_handlers()
self._sockets = None
await self._srv.startup(sockets=self._sockets)
if self._srv.should_exit:
return
self.fut = asyncio.ensure_future(self._srv.main_loop())
async def stop(self) -> None:
if self._srv is None:
raise UserWarning
await self._srv.shutdown(sockets=self._sockets)
self.fut.cancel()
async def health(self) -> None:
pass
def test_run_chain(tls_certificate_pem_path):
config = Config(
app=app,
loop="asyncio",
limit_max_requests=1,
ssl_certfile=tls_certificate_pem_path,
)
server = Server(config=config)
thread = threading.Thread(target=server.run)
thread.start()
while not server.started:
time.sleep(0.01)
with no_ssl_verification():
response = requests.get("https://127.0.0.1:8000")
assert response.status_code == 204
thread.join()
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))
async def _serve(self) -> None:
self.config.app = self.wsgi
server = Server(config=self.config)
await server.serve(sockets=self.sockets)
if not server.started:
sys.exit(Arbiter.WORKER_BOOT_ERROR)
async def prepare(self) -> None:
cfg = Config(AppWrapper(self, self.fapp), **self.cfg.dict())
self._srv = Server(cfg)
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
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))
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())
