async def test_access_logging(use_colors, caplog):
config = Config(app=app, use_colors=use_colors)
with caplog_for_logger(caplog, "uvicorn.access"):
async with run_server(config):
async with httpx.AsyncClient() as client:
response = await client.get("http://127.0.0.1:8000")
assert response.status_code == 204
messages = [
record.message
for record in caplog.records
if record.name == "uvicorn.access"
]
assert '"GET / HTTP/1.1" 204' in messages.pop()
async def test_trace_logging_on_http_protocol(http_protocol, caplog):
config = Config(app=app, log_level="trace", http=http_protocol)
with caplog_for_logger(caplog, "uvicorn.error"):
async with run_server(config):
async with httpx.AsyncClient() as client:
response = await client.get("http://127.0.0.1:8000")
assert response.status_code == 204
messages = [
record.message
for record in caplog.records
if record.name == "uvicorn.error"
]
assert any(" - HTTP connection made" in message for message in messages)
assert any(" - HTTP connection lost" in message for message in messages)
async def async_setup(self):
"""
The async method setup the runtime.
Setup the uvicorn server.
"""
with ImportExtensions(required=True):
from uvicorn import Config, Server
class UviServer(Server):
"""The uvicorn server."""
async def setup(self, sockets=None):
"""
Setup uvicorn server.
:param sockets: sockets of server.
"""
config = self.config
if not config.loaded:
config.load()
self.lifespan = config.lifespan_class(config)
self.install_signal_handlers()
await self.startup(sockets=sockets)
if self.should_exit:
return
async def serve(self, **kwargs):
"""
Start the server.
:param kwargs: keyword arguments
"""
await self.main_loop()
from .....helper import extend_rest_interface
uvicorn_kwargs = self.args.uvicorn_kwargs or {}
self._server = UviServer(
config=Config(
app=extend_rest_interface(get_fastapi_app(self.args, self.logger)),
host=__default_host__,
port=self.args.port_expose,
ws_max_size=1024 * 1024 * 1024,
log_level=os.getenv('JINA_LOG_LEVEL', 'error').lower(),
**uvicorn_kwargs
)
)
await self._server.setup()
async def test_access_logging(capsys):
config = Config(
app=app,
loop="asyncio",
limit_max_requests=1,
log_config=test_logging_config,
)
async with run_server(config):
async with httpx.AsyncClient() as client:
response = await client.get("http://127.0.0.1:8000")
assert response.status_code == 204
captured = capsys.readouterr()
assert '"GET / HTTP/1.1" 204' in captured.out
assert "uvicorn.access" in captured.out
async def test_trace_logging(capsys):
config = Config(
app=app,
loop="asyncio",
limit_max_requests=1,
log_config=test_logging_config,
log_level="trace",
)
async with run_server(config):
async with httpx.AsyncClient() as client:
response = await client.get("http://127.0.0.1:8000")
assert response.status_code == 204
captured = capsys.readouterr()
assert '"GET / HTTP/1.1" 204' in captured.out
assert "[TEST_ACCESS] TRACE" not in captured.out
def setup_app_and_run(directory, config_path, runner, tool_override):
uvicorn_config = Config(app, host="127.0.0.1", port=8889, log_level="info")
uvicorn_config.setup_event_loop()
server = Server(uvicorn_config)
app.loop = asyncio.get_event_loop()
# EM
app.em = EventEmitter(app.loop)
config = read_toml_config(config_path, tool_override)
# TODO: Re-add support for multiple test suites
app.suite = TestSuite(config["name"], runner, app.em, config)
app.suites: Dict[str, TestSuite] = {config["name"]: app.suite}
# Tests
app.tests = Tests(app.suites)
app.ws_client = WebsocketClients()
app.directory = directory
async def forward_notifications(message):
LOGGER.debug("Forwarding to %d clients: %r",
len(app.ws_client.clients), message)
data = {
"jsonrpc": "2.0",
"id": None,
"method": "test",
"params": message
}
await app.ws_client.broadcast(json.dumps(data))
app.em.register(forward_notifications)
app.em.register(process_notification)
app.loop.run_until_complete(server.serve())
def create(loop, config, *, mqtt=None, debug=False):
global mqtt_client
mqtt_client = mqtt
if debug:
log_level = logging.DEBUG
else:
log_level = logging.INFO
servers = []
for listener in config['listeners']:
webapp_config = Config(app=app.app, loop=loop, log_config=None, log_level=log_level, debug=debug, **config['listeners'][listener])
server = SignalableServer(webapp_config)
servers.append(server)
return servers
def run(app, **kwargs):
# Config.configure_logging = functools.partial(override_configure_logging, Config) #overwrite uvicorn method
# kwargs["log_config"] = LOGGING_CONFIG #! overwrite
config = Config(app, **kwargs)
config.backlog = 2048 #! for some reason we need to specify this
# config.log_config = LOGGING_CONFIG #! overwrite write our own
server = Server(config=config)
if (config.reload or config.workers > 1) and not isinstance(app, str):
logger.warn(
"You must pass the application as an import string to enable 'reload' or 'workers'."
)
sys.exit(1)
if config.should_reload:
sock = config.bind_socket()
supervisor = StatReload(config, target=server.run, sockets=[sock])
supervisor.run()
elif config.workers > 1:
sock = config.bind_socket()
supervisor = Multiprocess(config, target=server.run, sockets=[sock])
supervisor.run()
else:
server.run()
async def test_trace_logging(caplog):
config = Config(app=app, log_level="trace")
with caplog_for_logger(caplog, "uvicorn.asgi"):
async with run_server(config):
async with httpx.AsyncClient() as client:
response = await client.get("http://127.0.0.1:8000")
assert response.status_code == 204
messages = [
record.message for record in caplog.records if record.name == "uvicorn.asgi"
]
assert "ASGI [1] Started scope=" in messages.pop(0)
assert "ASGI [1] Raised exception" in messages.pop(0)
assert "ASGI [2] Started scope=" in messages.pop(0)
assert "ASGI [2] Send " in messages.pop(0)
assert "ASGI [2] Send " in messages.pop(0)
assert "ASGI [2] Completed" in messages.pop(0)
async def run_app(self):
"""
Run app with the given parameters to init.
Not supposed to be used manually by user.
:return: None
"""
config = Config(app=self.app,
host=self._host,
port=self._port,
debug=self._debug,
ssl_certfile=self._ssl_context[0],
ssl_keyfile=self._ssl_context[1])
server = Server(config)
await server.serve()
await self._bot.close_session()
async def test_default_logging(use_colors, caplog):
config = Config(app=app, use_colors=use_colors)
with caplog_for_logger(caplog, "uvicorn.access"):
async with run_server(config):
async with httpx.AsyncClient() as client:
response = await client.get("http://127.0.0.1:8000")
assert response.status_code == 204
messages = [
record.message for record in caplog.records if "uvicorn" in record.name
]
assert "Started server process" in messages.pop(0)
assert "Waiting for application startup" in messages.pop(0)
assert "ASGI 'lifespan' protocol appears unsupported" in messages.pop(0)
assert "Application startup complete" in messages.pop(0)
assert "Uvicorn running on http://127.0.0.1:8000" in messages.pop(0)
assert '"GET / HTTP/1.1" 204' in messages.pop(0)
assert "Shutting down" in messages.pop(0)
def test_override_server_header_multiple_times():
config = Config(
app=app,
loop="asyncio",
limit_max_requests=1,
headers=[("Server", "over-ridden"), ("Server", "another-value")],
)
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.headers["server"] == "over-ridden, another-value"
and response.headers["date"])
thread.join()
def test_trace_logging(capsys):
config = Config(
app=app,
loop="asyncio",
limit_max_requests=1,
log_config=test_logging_config,
log_level="trace",
)
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()
captured = capsys.readouterr()
assert '"GET / HTTP/1.1" 204' in captured.out
assert "[TEST_ACCESS] TRACE" not in captured.out
def test_access_logging(capsys, http_protocol):
config = Config(
app=app,
loop="asyncio",
http=http_protocol,
limit_max_requests=1,
log_config=test_logging_config,
)
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()
captured = capsys.readouterr()
assert '"GET / HTTP/1.1" 204' in captured.out
assert "uvicorn.access" in captured.out
def test_add_additional_header():
config = Config(
app=app,
loop="asyncio",
limit_max_requests=1,
headers=[("X-Additional", "new-value")],
)
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.headers["x-additional"] == "new-value"
and response.headers["server"] == "uvicorn"
and response.headers["date"])
thread.join()
async def test_unknown_status_code(caplog):
async def app(scope, receive, send):
assert scope["type"] == "http"
await send({"type": "http.response.start", "status": 599, "headers": []})
await send({"type": "http.response.body", "body": b"", "more_body": False})
config = Config(app=app)
with caplog_for_logger(caplog, "uvicorn.access"):
async with run_server(config):
async with httpx.AsyncClient() as client:
response = await client.get("http://127.0.0.1:8000")
assert response.status_code == 599
messages = [
record.message
for record in caplog.records
if record.name == "uvicorn.access"
]
assert '"GET / HTTP/1.1" 599' in messages.pop()
async def serve_forever(self, is_ready_event: 'Event'):
with ImportExtensions(required=True):
from uvicorn import Config, Server
class UvicornCustomServer(Server):
def run(self, sockets=None):
# uvicorn only supports predefined event loops
# hence we implement a way to serve from a custom (already running) loop
asyncio.create_task(self.serve(sockets=sockets))
# change log_level for REST server debugging
config = Config(app=self.get_fastapi_app(),
host=self.args.host,
port=self.args.port_expose,
log_level='critical')
self._server = UvicornCustomServer(config=config)
self.logger.success(f'{self.__class__.__name__} is listening at: {self.args.host}:{self.args.port_expose}')
self._server.run()
is_ready_event.set()
def main():
import blockexp
directory = os.path.dirname(os.path.dirname(__file__))
reloader = StatReload(Config(
app=None,
debug=True,
reload_dirs=[directory],
))
logger: Logger = reloader.config.logger_instance
while True:
uvicorn.run(
f"{__name__}:app",
host='0.0.0.0',
port=8000,
debug=True and RELOAD,
reload=RELOAD,
reload_dirs=[directory],
)
if not RELOAD:
break
logger.error("FAILURE RELOAD")
while True:
time.sleep(0.3)
if reloader.should_restart():
reloader.clear()
# noinspection PyBroadException
try:
reload(blockexp)
init_app(debug=True)
except Exception:
traceback.print_exc()
logger.error("FAILURE RELOAD")
else:
break
async def start(self):
with ImportExtensions(required=True):
from uvicorn import Config, Server
self.logger.warning('you are using a REST gateway, which is still in early beta version. '
'advanced features such as prefetch and streaming are disabled.')
class UvicornCustomServer(Server):
# uvicorn only supports predefined event loops
# hence we implement a way to serve from a custom (already running) loop
def run(self, sockets=None):
return asyncio.get_event_loop().create_task(self.serve(sockets=sockets))
# change log_level for REST server debugging
self._config = Config(app=self.app, host=self.host, port=self.port_expose, log_level='critical')
self._server = UvicornCustomServer(config=self._config)
self.logger.success(f'gateway (REST) is listening at: {self.host}:{self.port_expose}')
self._server.run()
await self.is_gateway_ready.wait()
return self
def run_receiver(
app: FastAPI,
event_loop: asyncio.AbstractEventLoop,
handlers: List[Callable[[signal.Signals, Optional[FrameType]], None]],
) -> Server:
"""
NOTE: Uvicorn override signal handler for eventloop in the case of "ctrl-c" and "kill pid".
So, tasks in eventloop other than "Uvicorn" cannot exit if "ctrl-c" and "kill pid".
To solve it, inject signal handler for other tasks.
"""
class SubServer(Server): # type: ignore
def handle_exit(self, sig: signal.Signals,
frame: Optional[FrameType]) -> None:
super().handle_exit(sig, frame)
for handler in handlers:
handler(sig, frame)
config = Config(app=app, loop=event_loop, log_level=logging.ERROR)
server = SubServer(config)
return server
def test_trace_logging(capsys):
class App:
def __init__(self, scope):
if scope["type"] != "http":
raise Exception()
async def __call__(self, receive, send):
await send({
"type": "http.response.start",
"status": 204,
"headers": []
})
await send({
"type": "http.response.body",
"body": b"",
"more_body": False
})
class CustomServer(Server):
def install_signal_handlers(self):
pass
config = Config(
app=App,
loop="asyncio",
limit_max_requests=1,
log_config=test_logging_config,
log_level="trace",
)
server = CustomServer(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()
captured = capsys.readouterr()
assert '"GET / HTTP/1.1" 204' in captured.out
assert "[TEST_ACCESS] TRACE" not in captured.out
def runserver(host: str, port: str, debug: bool, initdb: bool, resetdb: bool,
verbose: bool):
"""
Run the FastAPI Server.
:param host: Host to run it on.
:param port: Port to run it on.
:param debug: Run server in debug mode?
:param initdb: Create models before running API?
:param verbose: Set logging to DEBUG instead of INFO
"""
config.set_debug(debug)
if verbose:
logging.basicConfig(level=logging.DEBUG)
if not run_async(
prepare_postgres(retries=6,
interval=10.0,
db_uri=config.postgres_uri(),
loop=loop)):
exit(1) # Connecting to our postgres server failed.
server_config = Config("api.app:app", host=host, port=port, debug=debug)
server = Server(config=server_config)
async def worker():
if initdb:
await safe_create_tables(verbose=verbose)
elif resetdb:
await delete_tables(verbose=verbose)
await safe_create_tables(verbose=verbose)
await server.serve()
run_async(worker())
def __init__(self, _mock: Mock):
self._id = _mock.id
self._mock = _mock
_headers = [('server', 'swavan')]
_config = Config(app=SwaVanHttp(_mock).app,
host="localhost",
headers=_headers,
port=int(_mock.port),
access_log=False)
if _mock.enable_https:
_key = full_path("data/__certs__/swavan.key")
_crt = full_path("data/__certs__/swavan.crt")
if _mock.use_default_cert:
if os.path.isfile(_key) and os.path.isfile(_crt):
_config.ssl_keyfile = _key
_config.ssl_certfile = _crt
SwaVanLogRecorder.send_log(f"Using default cert")
else:
if os.path.isfile(_mock.ssl_key_file_url) and os.path.isfile(
_mock.ssl_cert_file_url):
_config.ssl_keyfile = _mock.ssl_key_file_url
_config.ssl_certfile = _mock.ssl_cert_file_url
SwaVanLogRecorder.send_log(f"Using custom cert")
self._core_server = Server(config=_config)
return plan.as_dict()
else:
raise HTTPException(status_code=404, detail='no such plan')
@app.put("/plans/")
async def add_plan(routine: Routine,
region: int,
first_uik: int,
last_uik: int,
hour_start: int = 1,
hour_end: int = 2):
"""
Добавить план.
"""
id = max(state.plans or [0]) + 1
state.plans[id] = dict(id=id,
routine=str(routine),
finished=False,
region=region,
first_uik=first_uik,
last_uik=last_uik,
hour_start=hour_start,
hour_end=hour_end)
queue.put_nowait(state.plans[id])
return state.plans[id].as_dict()
server = Server(Config(app))
server.install_signal_handlers = lambda *a: None # Do not catch signals
def web_app(loop):
config = Config(app=app, loop=loop, port=8001, host='0.0.0.0')
server = Server(config)
return server
app = VersionedFastAPI(app, version="1.0.0", prefix_format="/v{major}.{minor}", enable_latest=True)
@app.get("/")
async def read_items() -> Any:
html_content = """
<html>
<head>
<title>NMEA Injector</title>
</head>
</html>
"""
return HTMLResponse(content=html_content, status_code=200)
if __name__ == "__main__":
loop = asyncio.new_event_loop()
# # Running uvicorn with log disabled so loguru can handle it
config = Config(app=app, loop=loop, host="0.0.0.0", port=2748, log_config=None)
server = Server(config)
loop.create_task(controller.load_socks_from_settings())
if args.udp:
loop.create_task(controller.add_sock(NMEASocket(kind=SocketKind.UDP, port=args.udp, component_id=220)))
if args.tcp:
loop.create_task(controller.add_sock(NMEASocket(kind=SocketKind.TCP, port=args.tcp, component_id=221)))
loop.run_until_complete(server.serve())
async def run(self):
app = "bountydns.api.main:api"
kwargs = self.get_kwargs()
env = self.option("env")
self.load_env(f"api.{env}")
if self.should_import_check():
logger.info("performing import check")
from bountydns.api.main import api
logger.critical("starting api server with options: {}".format(
str(kwargs)))
from bountydns.db.checks import is_db_up, is_db_setup
if self.should_db_check():
self.db_register()
db_up = is_db_up()
if not db_up:
logger.critical("database not up error. please check logs")
return self.exit(1)
if self.option("db_setup"):
logger.critical("running database migration")
db_setup_options = self._args_to_dict(self.options)
if self.option("db_seed"):
db_setup_options["seed"] = True
await DbSetup(db_setup_options).run()
if self.should_db_check():
db_setup = is_db_setup()
if not db_setup:
logger.critical("database not setup error. please check logs")
return self.exit(1)
from bountydns.broadcast import is_broadcast_up
if self.should_bcast_check():
bcast_up = await is_broadcast_up()
if not bcast_up:
logger.critical(
"broadcast (queue) not up error. please check logs")
return self.exit(1)
if self.option("db_seed_env", False):
self.seed_from_env()
# taken from uvicorn/main.py:run
config = UvicornConfig(app, **kwargs)
server = UvicornServer(config=config)
if isinstance(app, str) and (config.debug or config.reload):
sock = config.bind_socket()
supervisor = StatReload(config)
logger.warning(f"running bountydns api in dev mode...")
return supervisor.run(server.run, sockets=[sock])
elif config.workers > 1:
sock = config.bind_socket()
supervisor = Multiprocess(config)
logger.warning(f"running bountydns api in worker mode...")
return supervisor.run(server.run, sockets=[sock])
else:
sockets = None
logger.warning(f"running bountydns api in standard mode...")
return await server.serve(sockets=sockets)
def version():
"""Route for retrieving server version."""
return Response(status_code=200, content=MDAI_DEPLOY_API_VERSION)
@app.get("/has-testing-metrics")
def has_testing_metrics():
"""Route for metric evaluation check."""
headers = {"Content-Type": "application/msgpack"}
data = {"hasTestingMetrics": False}
if hasattr(mdai_model, "evaluate_on_batch") and callable(mdai_model.evaluate_on_batch):
data["hasTestingMetrics"] = True
return Response(
status_code=200, content=msgpack.packb(data, use_bin_type=True), headers=headers
)
if __name__ == "__main__":
from mdai_deploy import MDAIModel
mdai_model = MDAIModel()
mdai_model_ready = True
loop = asyncio.new_event_loop()
config = Config(app=app, host="0.0.0.0", port="6324", workers=1)
server = Server(config)
loop.run_until_complete(server.serve())
def main():
config = Config(app=app, host='0.0.0.0', port=int(PORT), debug=True)
server = Server(config=config)
server.run()
def setup_logging():
# intercept everything at the root logger
logging.root.handlers = [InterceptHandler()]
logging.root.setLevel(LOG_LEVEL)
# remove every other logger's handlers
# and propagate to root logger
for name in logging.root.manager.loggerDict.keys():
logging.getLogger(name).handlers = []
logging.getLogger(name).propagate = True
# configure loguru
logger.configure(handlers=[{"sink": sys.stdout, "serialize": JSON_LOGS}])
if __name__ == '__main__':
server = Server(
Config(
"tdb.camerasuite.app:app",
host="0.0.0.0",
log_level=LOG_LEVEL,
), )
# setup logging last, to make sure no library overwrites it
# (they shouldn't, but it happens)
setup_logging()
server.run()
