BackgroundService/Actors run context managers

[llucax]

The issue

There is a pattern that seems to come more and more, and is that when an actor (or background service) runs, it needs to allocate some resources, that should be cleaned up if the actor stops (either normally or due to an exception).

The most reliable way to do this is to use context managers to ensure proper cleanup, but sometimes this is not done, or when done it implies adding some extra indentation to the run method.

This also happens to background services, so it can be generalized and implemented there instead, somehow, because background service don't one one _run() method, but could have many tasks.

Possible solutions

Any solution should probably involve a AsyncExitStack, so users can easily register cleaning up stuff (context managers or cleanup functions) that will be called automatically when the _run() method ends.

For example, in the Actor implementation:

class Actor:
    async def _run_loop(self) -> None:
        """Run the actor's task continuously, managing restarts, cancellation, and termination.

        This method handles the execution of the actor's task, including
        restarts for unhandled exceptions, cancellation, or normal termination.

        Raises:
            asyncio.CancelledError: If the actor's `_run()` method is cancelled.
            Exception: If the actor's `_run()` method raises any other exception.
            BaseException: If the actor's `_run()` method raises any base exception.
        """
        _logger.info("Actor %s: Started.", self)
        n_restarts = 0
        while True:
            try:
                await self._delay_if_restart(n_restarts)
                async with AsyncExitStack() as exit_stack:
                    await self._run(exit_stack)
                _logger.info("Actor %s: _run() returned without error.", self)
            except asyncio.CancelledError:
                _logger.info("Actor %s: Cancelled.", self)
                raise
            except Exception:  # pylint: disable=broad-except
                _logger.exception("Actor %s: Raised an unhandled exception.", self)
                limit_str = "∞" if self._restart_limit is None else self._restart_limit
                limit_str = f"({n_restarts}/{limit_str})"
                if self._restart_limit is None or n_restarts < self._restart_limit:
                    n_restarts += 1
                    _logger.info("Actor %s: Restarting %s...", self, limit_str)
                    continue
                _logger.info(
                    "Actor %s: Maximum restarts attempted %s, bailing out...",
                    self,
                    limit_str,
                )
                raise
            except BaseException:  # pylint: disable=broad-except
                _logger.exception("Actor %s: Raised a BaseException.", self)
                raise
            break

        _logger.info("Actor %s: Stopped.", self)

Then some actor implementation can do:

class MyActor:
    def _run(self, exit_stack: AsyncExitStack) -> None:
        await exit_stack.enter_async_context(self._some_background_service)
        exit_stack.push_async_callback(self._my_cleanup)
        some_file = exit_stack.enter_context(open(self._some_file_path))

        # do stuff

This helps avoiding the extra indentation, but also by requiring to take an exit stack, we are probably reminding users that they need to take care of cleanup.