def test_override_signal(event_loop: AbstractEventLoop) -> None:
# hack signal handler as terminate will be ignored
event_loop.add_signal_handler(SIGINT, lambda sig, frame:..., SIGINT, None)
lazy_fire_terminate_signal(0.1)
# asynchronous dummy heavy process will be terminated 0.1 sec later
event_loop.run_until_complete(dummy_inf_loop(0.3))
def run_server(loop: AbstractEventLoop, root: str) -> None:
socket_connection = add_socket_connection(loop, root)
stdin_pipe_reader = loop.connect_read_pipe(
lambda: AdapterProtocol(socket_connection, root), sys.stdin)
loop.run_until_complete(stdin_pipe_reader)
loop.set_exception_handler(error_handler)
loop.run_forever()
def test_streaminglogger(event_loop: AbstractEventLoop) -> None:
logger_ = logger.StreamingLogger()
logger_.reset("xxx", "yyy")
logger_.log("test")
async def assert_logger(logger_: logger.StreamingLogger) -> None:
log = await logger_.dequeue()
assert log.log == "test"
assert log.id == "xxx"
event_loop.run_until_complete(assert_logger(logger_))
def add_socket_connection(loop: AbstractEventLoop,
root: str) -> SocketConnection:
local_root = find_local_root(original_directory=root)
socket_connection = SocketConnection(str(log_directory(root, local_root)),
"adapter.sock")
socket_connection.connect()
socket_connection.perform_handshake(_get_version(root))
# pyre-fixme[16]: `AbstractEventLoop` has no attribute `connect_accepted_socket`.
socket_reader = loop.connect_accepted_socket(SocketProtocol,
socket_connection.socket)
loop.run_until_complete(socket_reader)
return socket_connection
def test_handle_exit(
event_loop: AbstractEventLoop,
_base: Type[BaseWorker],
) -> None:
# In "_run", if terminated (called handle_exit) once in a method,
# loop will be soon broken before calling next method
event_loop.run_until_complete(_base(freq=0.01)._run(event_loop))
# no loop if handle_exit has been already called
base = _base(freq=0.01)
base.handle_exit(SIGINT, None)
base.handle_exit(SIGINT, None)
event_loop.run_until_complete(base._run(event_loop))
def run_server(loop: AbstractEventLoop, root: str) -> None:
logging.basicConfig(
filename=_get_log_file(root),
level=logging.DEBUG,
format="%(asctime)s %(message)s",
datefmt="%m/%d/%Y %I:%M:%S %p",
filemode="w",
)
logging.info("Starting adapter.")
socket_connection = add_socket_connection(loop, root)
stdin_pipe_reader = loop.connect_read_pipe(
lambda: AdapterProtocol(socket_connection, root), sys.stdin)
loop.run_until_complete(stdin_pipe_reader)
loop.set_exception_handler(error_handler)
loop.run_forever()
def _cancel_tasks(to_cancel: Set['asyncio.Task[Any]'],
loop: AbstractEventLoop) -> None:
if not to_cancel:
return
for task in to_cancel:
task.cancel()
loop.run_until_complete(
gather(*to_cancel, loop=loop, return_exceptions=True))
for task in to_cancel:
if task.cancelled():
continue
if task.exception() is not None:
loop.call_exception_handler({
'message': 'unhandled exception during asyncio.run() shutdown',
'exception': task.exception(),
'task': task,
})
def iter_over_async(iterable: AsyncIterable[_T_co], loop: AbstractEventLoop) -> Generator[_T_co, None, None]:
# https://stackoverflow.com/questions/63587660/
iterator = iterable.__aiter__()
while True:
try:
yield loop.run_until_complete(iterator.__anext__())
except StopAsyncIteration:
break
def test_queue_handler(event_loop: AbstractEventLoop) -> None:
handler = log_streamer.QueueHandler()
event_loop.run_until_complete(workflow(handler))
queues = handler._queues
assert queues.get("xxx").get_nowait() == "test-x\n"
assert queues.get("yyy").get_nowait() == "test-y\n"
assert not queues.get("zzz")
async def delete(handler):
# raise
await handler.delete("aaa")
# pop successfully
await handler.delete("xxx")
event_loop.run_until_complete(delete(handler))
assert not queues.get("xxx")
def test_queuefilehandler(event_loop: AbstractEventLoop) -> None:
"""NOTE: QueueFileHandler add automatically if log is sent"""
with tempfile.TemporaryDirectory() as f:
logdir = Path(f) / "log"
handler = log_streamer.QueueFileHandler(str(logdir.resolve()))
event_loop.run_until_complete(workflow(handler))
with (logdir / "xxx").open() as fx:
assert fx.read() == "test-x\\n"
with (logdir / "yyy").open() as fy:
assert fy.read() == "test-y\\n"
with (logdir / "zzz").open() as fz:
assert fz.read() == "test-z\\n"
async def delete(handler):
# do nohing
await handler.delete("xxx")
event_loop.run_until_complete(delete(handler))
def test_locallogstreamer(capsys, event_loop: AbstractEventLoop) -> None:
logger = StreamingLogger()
logger.reset("xxx", "yyy")
streamer = log_streamer.LocalLogStreamer(
[ToyHandler()],
logger,
)
async def _toy_logging(logger: StreamingLogger,
streamer: log_streamer.LocalLogStreamer) -> None:
await asyncio.sleep(0.1)
# logging by logger
logger.log("test\n")
# log will be sent into streamer, and handler, then printted out
await asyncio.sleep(0.3)
streamer.handle_exit(SIGINT, None)
event_loop.create_task(streamer.entry_point())
event_loop.run_until_complete(_toy_logging(logger, streamer))
event_loop.stop()
captured = capsys.readouterr()
assert captured.out == "toy-test\n"
def launch_web_server(
settings: Settings,
loop: Loop,
port: int,
) -> None: # pragma: no cover
app = build_web_app()
runner = web.AppRunner(app)
loop.run_until_complete(runner.setup())
loop.run_until_complete(initialize_connection("spellbot-web"))
site = web.TCPSite(runner, settings.HOST, port)
loop.run_until_complete(site.start())
logger.info("server running: http://%s:%s", settings.HOST, port)
def test_baselogstreamer(capsys, event_loop: AbstractEventLoop) -> None:
event_loop.run_until_complete(ToyLogStreamer([ToyHandler()]).streaming())
captured = capsys.readouterr()
assert captured.out == "toy-test\n"
_streamer = ToyLogStreamer([ToyHandler()])
_streamer.add("yyy")
event_loop.run_until_complete(_streamer.streaming())
captured = capsys.readouterr()
assert captured.out == "toy-test\ntoy-test\n"
_streamer.delete("yyy")
event_loop.run_until_complete(_streamer.streaming())
captured = capsys.readouterr()
assert captured.out == "toy-test\n"
_streamer = ToyLogStreamer([ToyHandler()])
# exit mode
_streamer.handle_exit(SIGINT, None)
assert _streamer.should_exit and not _streamer.force_exit
# force exit mode
_streamer.handle_exit(SIGINT, None)
assert _streamer.should_exit and _streamer.force_exit
def run_null_server(loop: AbstractEventLoop) -> None:
stdin_pipe_reader = loop.connect_read_pipe(NullServerAdapterProtocol, sys.stdin)
loop.run_until_complete(stdin_pipe_reader)
loop.run_forever()
def run_async_code(function: Callable[..., Any], loop: AbstractEventLoop) -> Any:
return loop.run_until_complete(function())
def test_override_signal_but_timeout_works(
event_loop: AbstractEventLoop) -> None:
# check timeout works or not
event_loop.add_signal_handler(SIGINT, lambda sig, frame:..., SIGINT, None)
lazy_fire_terminate_signal(0.1)
event_loop.run_until_complete(dummy_inf_loop(0.3))