refactor: make event handlers asynchronous

The event handlers have been made asynchronous to allow them to perform
async I/O as needed. Tasks can also be submitted which are checked for
completion so that their result/exception can be retrieved and reported
back to the user.

austin_tui/__main__.py

@@ -23,7 +23,7 @@
 import asyncio
 import sys
 from textwrap import wrap
-from typing import Any, List, Optional
+from typing import Any, Callable, List, Optional
 
 from austin import AustinError
 from austin.aio import AsyncAustin
@@ -114,10 +114,15 @@ def on_terminate(self, stats: str) -> None:
  def on_view_event(self, event: AustinView.Event, data: Any = None) -> None:
  """View events handler."""
 
- def _unhandled() -> None:
+ def _unhandled(_: Any) -> None:
  raise RuntimeError(f"Unhandled view event: {event}")
 
- {AustinView.Event.QUIT: self.shutdown}.get(event, _unhandled)()
+ {
+ AustinView.Event.QUIT: self.on_shutdown,
+ AustinView.Event.EXCEPTION: self.on_exception,
+ }.get(event, _unhandled)(
+ data
+ ) # type: ignore[operator]
 
  async def start(self, args: List[str]) -> None:
  """Start Austin and catch any exceptions."""
@@ -157,6 +162,15 @@ def shutdown(self) -> None:
 
  asyncio.get_event_loop().stop()
 
+ def on_shutdown(self, _: Any = None) -> None:
+ """The shutdown view event handler."""
+ self.shutdown()
+
+ def on_exception(self, exc: Exception) -> None:
+ """The exception view event handler."""
+ self.shutdown()
+ raise exc
+
 
 def main() -> None:
  """Main function."""

austin_tui/controllers/austin.py

@@ -283,9 +283,6 @@ def _dump_stats() -> None:
  except IOError as e:
  self.view.notification.set_text(f"Failed to save stats: {e}")
 
- # TODO: This is very bad because the return value is an awaitable that
- # we are not awaiting. If an exception is thrown then we never retrieve
- # it. What's worse is that this could potentially mess up the output :(.
- asyncio.get_event_loop().run_in_executor(None, _dump_stats)
+ self.view.submit_task(_dump_stats)
 
  return True

austin_tui/view/__init__.py

@@ -22,9 +22,23 @@
 
 from abc import ABC
 import asyncio
+from asyncio.coroutines import coroutine
+from asyncio.coroutines import iscoroutine
 import curses
 import sys
-from typing import Any, Callable, Dict, List, Optional, TextIO, Type
+from typing import (
+ Any,
+ Awaitable,
+ Callable,
+ Coroutine,
+ Dict,
+ Generator,
+ List,
+ Optional,
+ TextIO,
+ Type,
+ Union,
+)
 
 from importlib_resources import files
 from lxml.etree import _Comment as Comment
@@ -101,15 +115,27 @@ def __init__(self, name: str) -> None:
 
  def _create_tasks(self) -> None:
  loop = asyncio.get_event_loop()
+ event_handlers = set(self._event_handlers.values())
  self._tasks = [
  loop.create_task(coro())
  for coro in (
  attr
  for attr in (getattr(self, name) for name in dir(self))
- if callable(attr) and asyncio.iscoroutinefunction(attr)
+ if callable(attr)
+ and asyncio.iscoroutinefunction(attr)
+ and attr not in event_handlers
  )
  ]
 
+ def on_exception(self, exc: Exception) -> None:
+ """Default task exception callback.
+
+ This simply closes the view and re-raises the exception. Override in
+ sub-classes with custom logic.
+ """
+ self.close()
+ raise exc
+
  async def _input_loop(self) -> None:
  if not self.root_widget:
  raise RuntimeError("Missing root widget")
@@ -120,12 +146,29 @@ async def _input_loop(self) -> None:
  if not self.root_widget._win:
  continue
 
+ # Handle user input on the root widget
  try:
- if self._event_handlers[self.root_widget._win.getkey()]():
+ if await self._event_handlers[self.root_widget._win.getkey()]():
  self.root_widget.refresh()
  except (KeyError, curses.error):
  pass
 
+ # Retrieve the result of finished tasks
+ finished_tasks = []
+ running_tasks = []
+ for task in self._tasks:
+ if task.done():
+ finished_tasks.append(task)
+ else:
+ running_tasks.append(task)
+ self._tasks = running_tasks
+
+ for task in finished_tasks:
+ try:
+ task.result()
+ except Exception as exc:
+ self.on_exception(exc)
+
  def _build(self, node: Element) -> Widget:
  _validate_ns(node)
  widget_class = QName(node).localname
@@ -168,6 +211,27 @@ def open(self) -> None:
 
  self._create_tasks()
 
+ def submit_task(
+ self,
+ task: Union[
+ asyncio.Task,
+ Coroutine[None, None, None],
+ Callable[[], Any],
+ ],
+ ) -> None:
+ """Submit a task to run concurrently in the event loop.
+
+ A task can be an :class:`asyncio.Task` object, a coroutine or a plain
+ callable object. Any exception thrown within the task can be retrieved
+ from the ``on_exception`` callback.
+ """
+ if isinstance(task, asyncio.Task):
+ self._tasks.append(task)
+ elif iscoroutine(task):
+ self._tasks.append(asyncio.create_task(task)) # type: ignore[arg-type]
+ else:
+ self._tasks.append(asyncio.get_event_loop().run_in_executor(None, task)) # type: ignore[arg-type]
+
  def close(self) -> None:
  """Close the view."""
  if not self._open or not self.root_widget:
@@ -202,7 +266,7 @@ def _parse(view_node: Element) -> View:
 
  root, *rest = view_node
  view.root_widget = view._build(root)
- view.connect("KEY_RESIZE", view.root_widget.resize)
+ view.connect("KEY_RESIZE", view.root_widget.on_resize)
 
  def _add_children(widget: Container, node: Element) -> None:
  for child in node:

austin_tui/view/austin.py

@@ -44,6 +44,7 @@ class AustinView(View):
  class Event(Enum):
  """Austin View Events."""
 
+ EXCEPTION = 0
  QUIT = 1
 
  def __init__(
@@ -63,62 +64,70 @@ def __init__(
 
  self._stopped = False
 
- def on_quit(self) -> bool:
+ def on_exception(self, exc: Exception) -> None:
+ """The on exception Austin view handler."""
+ if not self.callback:
+ raise RuntimeError(
+ "AustinTUI requires a callback to handle exception events."
+ )
+ self.callback(self.Event.EXCEPTION, exc)
+
+ async def on_quit(self) -> bool:
  """Handle Quit event."""
  if not self.callback:
  raise RuntimeError("AustinTUI requires a callback to handle quit events.")
  self.callback(self.Event.QUIT, None)
  return False
 
- def on_next_thread(self) -> bool:
+ async def on_next_thread(self) -> bool:
  """Handle next thread event."""
  if self._austin_controller.push(AustinEvent.CHANGE_THREAD, ThreadNav.NEXT):
  self.table.draw()
  self.stats_view.refresh()
  return True
  return False
 
- def on_previous_thread(self) -> bool:
+ async def on_previous_thread(self) -> bool:
  """Handle previous thread event."""
  if self._austin_controller.push(AustinEvent.CHANGE_THREAD, ThreadNav.PREV):
  self.table.draw()
  self.stats_view.refresh()
  return True
  return False
 
- def on_full_mode_toggled(self) -> bool:
+ async def on_full_mode_toggled(self) -> bool:
  """Handle Full Mode toggle."""
  self.full_mode_cmd.toggle()
  self._austin_controller.push(AustinEvent.TOGGLE_FULL_MODE)
  self.table.draw()
  self.stats_view.refresh()
  return True
 
- def on_save(self, data: Any = None) -> bool:
+ async def on_save(self, data: Any = None) -> bool:
  """Handle Save event."""
  self.notification.set_text("Saving collected statistics ...")
  self.root_widget.refresh()
  return self._austin_controller.push(AustinEvent.SAVE)
 
- def on_table_up(self, data: Any = None) -> bool:
+ async def on_table_up(self, data: Any = None) -> bool:
  """Handle Up Arrow on the table widget."""
  self.stats_view.scroll_up()
  self.stats_view.refresh()
  return False
 
- def on_table_down(self, data: Any = None) -> bool:
+ async def on_table_down(self, data: Any = None) -> bool:
  """Handle Down Arrow on the table widget."""
  self.stats_view.scroll_down()
  self.stats_view.refresh()
  return False
 
- def on_table_pgup(self, data: Any = None) -> bool:
+ async def on_table_pgup(self, data: Any = None) -> bool:
  """Handle Page Up on the table widget."""
  self.stats_view.scroll_up(self.table.height - 1)
  self.stats_view.refresh()
  return False
 
- def on_table_pgdown(self, data: Any = None) -> bool:
+ async def on_table_pgdown(self, data: Any = None) -> bool:
  """Handle Page Down on the table widget."""
  self.stats_view.scroll_down(self.table.height - 1)
  self.stats_view.refresh()

austin_tui/widgets/window.py

@@ -36,6 +36,10 @@ def __init__(self, name: str) -> None:
  super().__init__(name)
  self.win = self
 
+ async def on_resize(self) -> bool:
+ """The resize event handler."""
+ return self.resize()
+
  def resize(self) -> bool:
  """Resize the window.
 

noxfile.py

@@ -56,13 +56,13 @@ def lint(session):
  session.run("flake8", *LINT_LOCATIONS, "--exclude", *LINT_EXCLUDES)
 
 
-@nox.session(python="3.7")
+@nox.session(python="3.9")
 def mypy(session):
  session.install("mypy")
  session.run("mypy", "--show-error-codes", *MYPY_LOCATIONS)
 
 
-@nox.session(python="3.7")
+@nox.session(python="3.9")
 def coverage(session):
  """Upload coverage data."""
  install_with_constraints(session, "coverage[toml]", "codecov")

pyproject.toml

@@ -52,7 +52,7 @@ profile = "google"
 austin-tui = "austin_tui.__main__:main"
 
 [tool.poetry.dependencies]
-austin-python = {version = "^1.0.0*", allow-prereleases = true}
+austin-python = {version = "^1.1.0*", allow-prereleases = true}
 importlib-resources = "^2.0.1"
 lxml = "^4.5.1"
 python = "^3.6"