class HTTPRunner:
def __init__(self, http_app: Callable):
self._http_app = http_app
self.log = logging.getLogger(self.__class__.__name__)
self._uv_server = None
def start_http(self):
self.log.info("Starting the HTTP thread")
self._http_thread = threading.Thread(target=self._run_uvicorn,
name="HTTP-Thread")
self._http_thread.start()
self.log.info("HTTP thread started")
def stop_http(self):
self.log.info("Stopping the HTTP thread ")
self._uv_server.handle_exit(None, None)
self.log.info("Waiting for the HTTP thread to finish")
self._http_thread.join()
def _run_uvicorn(self):
self.log.info("Starting a new event loop in current thread")
loop = uvloop.new_event_loop()
#loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self.log.info("Running the uvicorn")
from uvicorn import Server, Config
uvconfig = Config(self._http_app,
port=5000,
log_level="debug",
loop="asyncio")
self._uv_server = Server(uvconfig)
self._uv_server.run()
def server(self, loop):
"""
prepare the server and initialize it
so it be ready to run inside a thread
this code is inspired by the following link:
- https://github.com/encode/uvicorn/issues/706#issuecomment-652220153
"""
app = FastAPI()
app.x = self
app.redis = redis.Redis(
host=self.redis_config["host"],
port=self.redis_config["port"],
password=self.redis_config["password"],
db=self.redis_config["db"]
)
app.include_router(routes.router)
config = Config(
app=app,
loop=loop,
workers=self.server_workers_count,
port=self.server_listen_port,
host=self.server_listen_host,
access_log=self.enable_access_log,
debug=False
)
server = Server(config)
loop.run_until_complete(server.serve())
def parse_cli():
"""Run the FastAPI server"""
# Find numerical value of log level
try:
level_num = logger.level(LOG_LEVEL).no
except ValueError as err:
logging.error(
f"Unknown log level {err}. Use one of {', '.join(logger._core.levels)}"
)
raise SystemExit()
# Set up server
server = Server(
Config(
"api.main:app",
host="0.0.0.0",
log_level=level_num,
port=5000,
proxy_headers=True,
), )
# Set up logging last, to make sure no library overwrites it (they
# shouldn't, but it happens)
log.init(LOG_LEVEL)
# Start server
server.run()
async def app(event_loop, db, request):
globalregistry.reset()
settings = get_db_settings(request.node)
app = make_app(settings=settings, loop=event_loop)
server_settings = settings.get("test_server_settings", {})
host = server_settings.get("host", "127.0.0.1")
port = int(server_settings.get("port", 8000))
from uvicorn import Config, Server
config = Config(app, host=host, port=port, lifespan="on")
server = Server(config=config)
task = asyncio.ensure_future(server.serve(), loop=event_loop)
while app.app is None and not task.done():
# Wait for app initialization
await asyncio.sleep(0.05)
if task.done():
task.result()
await _clear_dbs(app.app.root)
yield host, port
server.should_exit = True
await asyncio.sleep(1) # There is no other way to wait for server shutdown
clear_task_vars()
def start_uvicorn():
uvicorn_config = Config('src.app:app',
host=settings.SERVICE_HOST,
port=settings.SERVICE_PORT,
log_level=settings.SERVICE_LOG_LEVEL.lower(),
loop="asyncio")
server = Server(config=uvicorn_config)
server.run()
def run_api(bot):
from uvicorn import Server, Config
web_cog = bot.get_cog("web")
if web_cog is None:
return
server = Server(Config(web_cog.app, host="0.0.0.0", port=1234))
server.config.setup_event_loop()
return bot.loop.create_task(server.serve())
async def create_server(config):
server = Server(config)
task = asyncio.ensure_future(server.serve())
try:
yield task
finally:
await server.shutdown()
task.cancel()
async def do_tests():
# Create dummy files
os.makedirs("tests")
os.makedirs("tests/client")
os.makedirs("tests/server")
os.makedirs("tests/server/empty_dir")
os.makedirs("tests/server/sub1")
os.makedirs("tests/server/sub1/sub2")
for filename in [
"tests/server/f1",
"tests/server/f2",
"tests/server/sub1/f3",
"tests/server/sub1/sub2/f4",
]:
async with aiofiles.open(filename, mode='wb') as f:
await f.write(os.urandom(10240))
# Launch server
http_mv_server.files_path = os.path.join(os.getcwd(), "tests/server")
http_mv_server.files_pattern = "**"
server = Server(
config=Config(http_mv_server.app, host='127.0.0.1', port=8000))
loop = asyncio.get_event_loop()
loop.create_task(server.serve(sockets=None))
await asyncio.sleep(2) # Create server
# Launch client
await http_mv_client("http://127.0.0.1:8000", "tests/client")
# Check
files_local = glob.glob("tests/**", recursive=True)
files_supposed = [
"tests/client/f1",
"tests/client/f2",
"tests/client/sub1/f3",
"tests/client/sub1/sub2/f4",
"tests\\client\\f1",
"tests\\client\\f2",
"tests\\client\\sub1\\f3",
"tests\\client\\sub1\\sub2\\f4",
]
for file in files_local:
if file in files_supposed:
os.remove(file)
os.rmdir("tests/client/sub1/sub2")
os.rmdir("tests/client/sub1")
os.rmdir("tests/client/")
# Exit server
server.handle_exit(None, None)
await asyncio.sleep(2) # Gracefully
# Clean
os.rmdir("tests/server/sub1/sub2")
os.rmdir("tests/server/sub1")
os.rmdir("tests/server/empty_dir")
os.rmdir("tests/server")
os.rmdir("tests")
def _start_uvicorn(app: 'FastAPI'):
config = Config(app=app,
host=jinad_args.host,
port=jinad_args.port_expose,
loop='uvloop',
log_level='error')
server = Server(config=config)
server.run()
daemon_logger.info('Goodbye!')
def uvicorn_serve(app: 'FastAPI'):
from uvicorn import Config, Server
config = Config(app=app,
host=server_config.HOST,
port=server_config.PORT,
loop='uvloop',
log_level='error')
server = Server(config=config)
server.run()
async def run_server(config: Config, sockets=None):
server = Server(config=config)
cancel_handle = asyncio.ensure_future(server.serve(sockets=sockets))
await asyncio.sleep(0.1)
try:
yield server
finally:
await server.shutdown()
cancel_handle.cancel()
def _start_uvicorn(app: 'FastAPI'):
config = Config(
app=app,
host=jinad_args.host,
port=jinad_args.port,
loop='uvloop',
log_level='error',
)
server = Server(config=config)
server.run()
def _start_uvicorn(app: 'FastAPI'):
from .config import server_config
config = Config(app=app,
host=server_config.HOST,
port=server_config.PORT,
loop='uvloop',
log_level='error')
server = Server(config=config)
server.run()
daemon_logger.info('Bye!')
def _start_uvicorn(app: 'FastAPI'):
config = Config(app=app,
host=jinad_args.host,
port=jinad_args.port_expose,
loop='uvloop',
log_level='error')
server = Server(config=config)
server.run()
from jina import __stop_msg__
daemon_logger.success(__stop_msg__)
def _run_uvicorn(self):
self.log.info("Starting a new event loop in current thread")
loop = uvloop.new_event_loop()
#loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self.log.info("Running the uvicorn")
from uvicorn import Server, Config
uvconfig = Config(self._http_app,
port=5000,
log_level="debug",
loop="asyncio")
self._uv_server = Server(uvconfig)
self._uv_server.run()
def __init__(self, name: str, port: Optional[int] = None, **kwargs):
"""
Args:
name: the name of the service
port: the port to bind to when serving, default will bind to an available port
**kwargs: forwarded to the uvicorn configuration.
"""
self._app = Starlette(debug=True)
self._route_lock = Lock()
# since the main thread won't catch errors in handlers, this class will store any error raised while handling,
# and raise them in the main thread as soon as we can
self._pending_exception: Optional[Exception] = None
if 'log_config' not in kwargs:
log_config = deepcopy(uvicorn_logging_config)
log_config['formatters']['access']['fmt'] = \
f'%(levelprefix)s {name} %(client_addr)s - "%(request_line)s" %(status_code)s'
log_config['formatters']['default'][
'fmt'] = f'%(levelprefix)s {name} %(message)s'
kwargs['log_config'] = log_config
kwargs.setdefault('host', '0.0.0.0')
self._port = port
config = Config(self._app, **kwargs, port=self._port)
self._server = Server(config)
self._serve_thread = Thread(name=f'{name}_thread',
target=self._server.run)
async def run(self, arguments, settings, app):
host = arguments.host or app.settings.get("host", "0.0.0.0")
port = arguments.port or app.settings.get("address",
settings.get("port"))
loggers = app.settings.get("logging")
if arguments.asgi_server == "uvicorn":
from uvicorn import Config # type: ignore
from uvicorn import Server # type: ignore
from uvicorn.config import LOGGING_CONFIG # type: ignore
config = Config(
app,
host=host,
port=port,
reload=arguments.reload,
log_config=loggers or LOGGING_CONFIG,
**app.server_settings.get("uvicorn", {}),
)
server = Server(config)
await server.serve()
elif arguments.asgi_server == "hypercorn":
from hypercorn.asyncio import serve # type: ignore
from hypercorn.config import Config # type: ignore
from hypercorn.logging import CONFIG_DEFAULTS # type: ignore
config = Config()
config.bind = [f"{host}:{port}"]
config.use_reloader = arguments.reload
config.logconfig_dict = loggers or CONFIG_DEFAULTS
config.accesslog = "-"
config.errorlog = "-"
await serve(app, config)
else:
raise Exception(f"Server {arguments.asgi_server} not supported")
def test_fragmentation():
def receive_all(sock):
chunks = []
while True:
chunk = sock.recv(1024)
if not chunk:
break
chunks.append(chunk)
return b"".join(chunks)
app = Response("Hello, world", media_type="text/plain")
def send_fragmented_req(path):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("127.0.0.1", 8000))
d = (
f"GET {path} HTTP/1.1\r\n" "Host: localhost\r\n" "Connection: close\r\n\r\n"
).encode()
split = len(path) // 2
sock.sendall(d[:split])
time.sleep(0.01)
sock.sendall(d[split:])
resp = receive_all(sock)
# see https://github.com/kmonsoor/py-amqplib/issues/45
# we skip the error on bsd systems if python is too slow
try:
sock.shutdown(socket.SHUT_RDWR)
except Exception: # pragma: no cover
pass
sock.close()
return resp
config = Config(app=app, http="httptools")
server = Server(config=config)
t = threading.Thread(target=server.run)
t.daemon = True
t.start()
time.sleep(1) # wait for uvicorn to start
path = "/?param=" + "q" * 10
response = send_fragmented_req(path)
bad_response = b"HTTP/1.1 400 Bad Request"
assert bad_response != response[: len(bad_response)]
server.should_exit = True
t.join()
def setup_server(host: str, port: int, log_level: str):
config = Config(
"tinychronicler:server",
host=host,
port=port,
log_level=log_level,
)
server = Server(config=config)
return server
async def serve():
config = Config(
app=APP,
host=settings.SERVER_HOST,
port=settings.SERVER_PORT
)
server = Server(config)
await server.serve()
async def api_run(loop1):
print('api')
asyncio.set_event_loop(loop1)
config = Config(app=app,
host="0.0.0.0",
loop=loop1,
port=5000,
reload=True)
server = Server(config)
await server.serve()
class UvicornServer:
app: FastAPI
config: Config
request_state: RequestState
prerun_tasks: list[Callable[[], Any]] = field(default_factory=list)
def __post_init__(self):
self.config.callback_notify = self.on_tick
@classmethod
def from_request(cls, request: UvicornServerRequest) -> UvicornServer:
app = FastAPI()
return cls(
app=app,
config=Config(
app,
host=request.address,
port=request.port,
timeout_notify=0.25,
log_config=None,
),
request_state=request.request_state,
)
def create_server(self) -> ExplorerServer:
self.server = Server(config=self.config)
return ExplorerServer(main=self.run)
async def on_tick(self) -> None:
if self.request_state.scheduler_session.is_cancelled:
print() # Linebreak after the echoed ^C on the terminal.
logger.info(" => Exiting...")
self.server.should_exit = True
def run(self) -> ExitCode:
logging.info("Starting the Explorer Web UI server...")
for task in self.prerun_tasks:
task()
self.server.run()
return 0
class SwaVanRestMockServer(SwaVanMockTask):
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)
def start(self):
if self._core_server:
self._core_server.run()
def stop(self):
self._core_server.should_exit = True
def set_id(self, _id: str):
self._id = _id
def set_mock(self, _mock: Mock):
self._mock = _mock
@property
def id(self) -> str:
return self._mock.id
def setup(self):
with ImportExtensions(required=True):
from uvicorn import Config, Server
# change log_level for REST server debugging
self._server = Server(config=Config(app=self._get_fastapi_app(),
host=self.args.host,
port=self.args.port_expose,
log_level='critical'))
self.logger.success(
f'{self.__class__.__name__} is listening at: {self.args.host}:{self.args.port_expose}'
)
def test_default_default_headers():
config = Config(app=app, 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("http://127.0.0.1:8000")
assert response.headers["server"] == "uvicorn" and response.headers["date"]
thread.join()
def configure(self, value: http_pb2.Server):
assert isinstance(value, http_pb2.Server), type(value)
app = _healthcheck_middleware(self._app)
app = OpenTelemetryMiddleware(app)
config = Config(
app,
value.bind.host,
value.bind.port,
log_config=None,
access_log=False,
)
self.server = Server(config)
logging.getLogger("uvicorn.error").setLevel(logging.ERROR)
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)
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())
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()
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()
