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, 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:
setup_child_process_logging(boot_info)
if boot_info.profile:
with profiler(f'profile_{cls._get_endpoint_name}'):
cls.run_process(boot_info)
else:
cls.run_process(boot_info)
async def run_process(self, event_bus: EndpointAPI) -> None:
try:
if self._boot_info.profile:
with profiler(f'profile_{self.get_endpoint_name()}'):
await self.do_run(event_bus)
else:
await self.do_run(event_bus)
except (trio.Cancelled, trio.MultiError):
# These are expected, when trinity is terminating because of a Ctrl-C
raise
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 _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
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)
async def run_process(self, event_bus: EndpointAPI) -> None:
try:
if self._boot_info.profile:
with profiler(f'profile_{self.get_endpoint_name()}'):
await self.do_run(event_bus)
else:
await self.do_run(event_bus)
except (trio.Cancelled, trio.MultiError):
# These are expected, when trinity is terminating because of a Ctrl-C
raise
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
def _prepare_spawn(self) -> None:
if self.boot_info.boot_kwargs.pop('profile', False):
with profiler(f'profile_{self.normalized_name}'):
self._spawn_start()
else:
self._spawn_start()
async def run_process(self, event_bus: EndpointAPI) -> None:
if self._boot_info.profile:
with profiler(f'profile_{self.get_endpoint_name()}'):
await self.do_run(event_bus)
else:
await self.do_run(event_bus)