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