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())