async def _do_run(self, boot_info: BootInfo) -> None:
with child_process_logging(boot_info):
endpoint_name = self.get_endpoint_name()
event_bus_service = AsyncioEventBusService(
boot_info.trinity_config,
endpoint_name,
)
async with background_asyncio_service(event_bus_service):
event_bus = await event_bus_service.get_event_bus()
try:
if boot_info.profile:
with profiler(f'profile_{self.get_endpoint_name()}'):
await self.do_run(boot_info, event_bus)
else:
# XXX: When open_in_process() injects a KeyboardInterrupt into us (via
# coro.throw()), we hang forever here, until open_in_process() times out
# and sends us a SIGTERM, at which point we exit without executing either
# the except or the finally blocks below.
# See https://github.com/ethereum/trinity/issues/1711 for more.
await self.do_run(boot_info, event_bus)
except KeyboardInterrupt:
# Currently we never reach this code path, but when we fix the issue above it
# will be needed.
return
finally:
# Once we start seeing this in the logs, we'll likely have figured the issue
# above.
logger.debug("%s: do_run() finished", self)
def run_process(cls, boot_info: BootInfo) -> None:
with child_process_logging(boot_info):
if boot_info.profile:
with profiler(f'profile_{cls.get_endpoint_name()}'):
trio.run(cls._do_run, boot_info)
else:
trio.run(cls._do_run, boot_info)
async def _do_run(self) -> None:
with child_process_logging(self._boot_info):
endpoint_name = self.get_endpoint_name()
event_bus_service = AsyncioEventBusService(
self._boot_info.trinity_config,
endpoint_name,
)
async with background_asyncio_service(
event_bus_service) as eventbus_manager:
event_bus = await event_bus_service.get_event_bus()
loop_monitoring_task = create_task(
self._loop_monitoring_task(event_bus),
f'AsyncioIsolatedComponent/{self.name}/loop_monitoring_task'
)
do_run_task = create_task(
self.do_run(event_bus),
f'AsyncioIsolatedComponent/{self.name}/do_run')
eventbus_task = create_task(
eventbus_manager.wait_finished(),
f'AsyncioIsolatedComponent/{self.name}/eventbus/wait_finished'
)
try:
max_wait_after_cancellation = 2
tasks = [do_run_task, eventbus_task, loop_monitoring_task]
if self._boot_info.profile:
with profiler(f'profile_{self.get_endpoint_name()}'):
await wait_first(tasks,
max_wait_after_cancellation)
else:
# XXX: When open_in_process() injects a KeyboardInterrupt into us (via
# coro.throw()), we hang forever here, until open_in_process() times
# out and sends us a SIGTERM, at which point we exit without executing
# either the except or the finally blocks below.
# See https://github.com/ethereum/trinity/issues/1711 for more.
try:
await wait_first(
tasks,
max_wait_after_cancellation,
)
except asyncio.TimeoutError:
self.logger.warning(
"Timed out waiting for tasks to terminate after cancellation: %s",
tasks)
except KeyboardInterrupt:
self.logger.debug("%s: KeyboardInterrupt", self)
# Currently we never reach this code path, but when we fix the issue above
# it will be needed.
return
finally:
# Once we start seeing this in the logs after a Ctrl-C, we'll likely have
# figured out the issue above.
self.logger.debug("%s: do_run() finished", self)
async def run_db_manager(
boot_info: BootInfo, get_base_db_fn: Callable[[BootInfo],
LevelDB]) -> None:
with child_process_logging(boot_info):
trinity_config = boot_info.trinity_config
manager = DBManager(get_base_db_fn(boot_info))
with trinity_config.process_id_file('database'):
with manager.run(trinity_config.database_ipc_path):
loop = asyncio.get_event_loop()
try:
await loop.run_in_executor(None, manager.wait_stopped)
finally:
# We always need to call stop() before returning as asyncio can't cancel the
# thread started by run_in_executor() and that would prevent
# open_in_process(run_db_manager, ...) from returning.
manager.stop()
async def _do_run(self) -> None:
with child_process_logging(self._boot_info):
event_bus_service = TrioEventBusService(
self._boot_info.trinity_config,
self.get_endpoint_name(),
)
async with background_trio_service(event_bus_service):
event_bus = await event_bus_service.get_event_bus()
async with trio.open_nursery() as nursery:
nursery.start_soon(self.run_process, event_bus)
try:
await trio.sleep_forever()
except KeyboardInterrupt:
self.logger.debug("%s: Got KeyboardInterrupt, exiting",
self.name)
nursery.cancel_scope.cancel()
async def _do_run(cls, boot_info: BootInfo) -> None:
with child_process_logging(boot_info):
endpoint_name = cls.get_endpoint_name()
event_bus_service = AsyncioEventBusService(
boot_info.trinity_config,
endpoint_name,
)
async with background_asyncio_service(event_bus_service):
event_bus = await event_bus_service.get_event_bus()
try:
if boot_info.profile:
with profiler(f'profile_{cls.get_endpoint_name()}'):
await cls.do_run(boot_info, event_bus)
else:
await cls.do_run(boot_info, event_bus)
except KeyboardInterrupt:
return
def run_database_process(boot_info: BootInfo, db_class: Type[LevelDB]) -> None:
with child_process_logging(boot_info):
trinity_config = boot_info.trinity_config
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(Eth1AppConfig)
base_db = db_class(db_path=app_config.database_dir)
chaindb = ChainDB(base_db)
if not is_database_initialized(chaindb):
chain_config = app_config.get_chain_config()
initialize_database(chain_config, chaindb, base_db)
manager = DBManager(base_db)
with manager.run(trinity_config.database_ipc_path):
try:
manager.wait_stopped()
except KeyboardInterrupt:
pass
async def _do_run(self) -> None:
with child_process_logging(self._boot_info):
endpoint_name = self.get_endpoint_name()
event_bus_service = AsyncioEventBusService(
self._boot_info.trinity_config,
endpoint_name,
)
async with background_asyncio_service(event_bus_service):
event_bus = await event_bus_service.get_event_bus()
try:
if self._boot_info.profile:
with profiler(f'profile_{self.get_endpoint_name()}'):
await self.do_run(event_bus)
else:
# XXX: When open_in_process() injects a KeyboardInterrupt into us (via
# coro.throw()), we hang forever here, until open_in_process() times out
# and sends us a SIGTERM, at which point we exit without executing either
# the except or the finally blocks below.
# See https://github.com/ethereum/trinity/issues/1711 for more.
await self.do_run(event_bus)
except KeyboardInterrupt:
# Currently we never reach this code path, but when we fix the issue above it
# will be needed.
return
except BaseException:
# Leaving trinity running after a component crashes can lead to unexpected
# behavior that'd be hard to debug/reproduce, so for now we shut it down if
# any component crashes unexpectedly.
event_bus.broadcast_nowait(ShutdownRequest(f"Unexpected error in {self}"))
# Because of an issue in the ComponentManager (see comment in
# _cleanup_component_task), when a component crashes and requests trinity to
# shutdown, there's still a chance its exception could be lost, so we log it
# here as well.
self.logger.exception(
"Unexpected error in component %s, shutting down trinity", self)
raise
finally:
# Once we start seeing this in the logs after a Ctrl-C, we'll likely have
# figured out the issue above.
self.logger.debug("%s: do_run() finished", self)
async def _do_run(self) -> None:
with child_process_logging(self._boot_info):
endpoint_name = self.get_endpoint_name()
event_bus_service = AsyncioEventBusService(
self._boot_info.trinity_config,
endpoint_name,
)
# FIXME: Must terminate component if event_bus_service terminates.
async with background_asyncio_service(event_bus_service):
event_bus = await event_bus_service.get_event_bus()
loop_monitoring_task = create_task(
self._loop_monitoring_task(event_bus),
f'AsyncioIsolatedComponent/{self.name}/loop_monitoring_task'
)
# FIXME: Must terminate component if loop_monitoring_task terminates.
async with cleanup_tasks(loop_monitoring_task):
try:
if self._boot_info.profile:
with profiler(
f'profile_{self.get_endpoint_name()}'):
await self.do_run(event_bus)
else:
# XXX: When open_in_process() injects a KeyboardInterrupt into us (via
# coro.throw()), we hang forever here, until open_in_process() times
# out and sends us a SIGTERM, at which point we exit without executing
# either the except or the finally blocks below.
# See https://github.com/ethereum/trinity/issues/1711 for more.
await self.do_run(event_bus)
except KeyboardInterrupt:
# Currently we never reach this code path, but when we fix the issue above
# it will be needed.
return
finally:
# Once we start seeing this in the logs after a Ctrl-C, we'll likely have
# figured out the issue above.
self.logger.debug("%s: do_run() finished", self)
