Refactor shutdown procedure

Author: willmcgugan

pyproject.toml

@@ -4,6 +4,19 @@ version = "0.1.1"
 description = "Text User Interface using Rich"
 authors = ["Will McGugan <[email protected]>"]
 license = "MIT"
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+]
+
 
 [tool.poetry.dependencies]
 python = "^3.7"

src/textual/_linux_driver.py

@@ -139,15 +139,21 @@ def _patch_iflag(cls, attrs: int) -> int:
             | termios.IGNCR
         )
 
+    def disable_input(self) -> None:
+        try:
+            if not self.exit_event.is_set():
+                signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+                self._disable_mouse_support()
+                self.exit_event.set()
+                if self._key_thread is not None:
+                    self._key_thread.join()
+        except Exception:
+            log.exception("error in disable_input")
+
     def stop_application_mode(self) -> None:
         log.debug("stop_application_mode()")
 
-        signal.signal(signal.SIGWINCH, signal.SIG_DFL)
-
-        self._disable_mouse_support()
-        self.exit_event.set()
-        if self._key_thread is not None:
-            self._key_thread.join()
+        self.disable_input()
 
         if self.attrs_before is not None:
             try:
@@ -190,12 +196,18 @@ def more_data() -> bool:
         read = os.read
 
         log.debug("started key thread")
-        while not self.exit_event.is_set():
-            selector_events = selector.select(0.1)
-            for _selector_key, mask in selector_events:
-                unicode_data = decode(read(fileno, 1024))
-                for event in parser.feed(unicode_data):
-                    send_event(event)
+        try:
+            while not self.exit_event.is_set():
+                selector_events = selector.select(0.1)
+                for _selector_key, mask in selector_events:
+                    if mask | selectors.EVENT_READ:
+                        unicode_data = decode(read(fileno, 1024))
+                        for event in parser.feed(unicode_data):
+                            send_event(event)
+        except Exception:
+            log.exception("error running key thread")
+        finally:
+            selector.close()
 
 
 if __name__ == "__main__":

src/textual/_timer.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import weakref
-from asyncio import Event, TimeoutError, wait_for
+from asyncio import CancelledError, Event, TimeoutError, wait_for
 from time import monotonic
 from typing import Awaitable, Callable
 
@@ -62,18 +62,21 @@ async def run(self) -> None:
         _interval = self._interval
         _wait = self._stop_event.wait
         start = monotonic()
-        while _repeat is None or count <= _repeat:
-            next_timer = start + (count * _interval)
-            try:
-                if await wait_for(_wait(), max(0, next_timer - monotonic())):
+        try:
+            while _repeat is None or count <= _repeat:
+                next_timer = start + (count * _interval)
+                try:
+                    if await wait_for(_wait(), max(0, next_timer - monotonic())):
+                        break
+                except TimeoutError:
+                    pass
+                event = events.Timer(
+                    self.sender, timer=self, count=count, callback=self._callback
+                )
+                try:
+                    await self.target.post_message(event)
+                except EventTargetGone:
                     break
-            except TimeoutError:
-                pass
-            event = events.Timer(
-                self.sender, timer=self, count=count, callback=self._callback
-            )
-            try:
-                await self.target.post_message(event)
-            except EventTargetGone:
-                break
-            count += 1
+                count += 1
+        except CancelledError:
+            pass

src/textual/_types.py

@@ -16,20 +16,12 @@
 
 
 class MessageTarget(Protocol):
-    async def post_message(
-        self,
-        message: "Message",
-        priority: Optional[int] = None,
-    ) -> bool:
+    async def post_message(self, message: "Message") -> bool:
         ...
 
 
 class EventTarget(Protocol):
-    async def post_message(
-        self,
-        message: "Message",
-        priority: Optional[int] = None,
-    ) -> bool:
+    async def post_message(self, message: "Message") -> bool:
         ...
 
 

src/textual/app.py

@@ -56,17 +56,18 @@ def __init__(
         self,
         console: Console = None,
         screen: bool = True,
-        driver: Type[Driver] = None,
+        driver_class: Type[Driver] = None,
         view: View = None,
         title: str = "Megasoma Application",
     ):
         super().__init__()
         self.console = console or get_console()
         self._screen = screen
-        self.driver = driver or LinuxDriver
+        self.driver_class = driver_class or LinuxDriver
         self.title = title
         self.view = view or LayoutView()
         self.children: set[MessagePump] = set()
+        self._driver: Driver | None = None
 
         self._action_targets = {"app": self, "view": self.view}
 
@@ -78,7 +79,7 @@ def run(
         cls, console: Console = None, screen: bool = True, driver: Type[Driver] = None
     ):
         async def run_app() -> None:
-            app = cls(console=console, screen=screen, driver=driver)
+            app = cls(console=console, screen=screen, driver_class=driver)
             await app.process_messages()
 
         asyncio.run(run_app())
@@ -95,11 +96,11 @@ async def process_messages(self) -> None:
             self.console.print_exception(show_locals=True)
 
     async def _process_messages(self) -> None:
-        log.debug("driver=%r", self.driver)
+        log.debug("driver=%r", self.driver_class)
         loop = asyncio.get_event_loop()
 
         loop.add_signal_handler(signal.SIGINT, self.on_keyboard_interupt)
-        driver = self.driver(self.console, self)
+        driver = self._driver = self.driver_class(self.console, self)
 
         active_app.set(self)
 
@@ -116,32 +117,53 @@ async def _process_messages(self) -> None:
             await super().process_messages()
         finally:
             try:
-                if self.children:
-
-                    async def close_all() -> None:
-                        for child in self.children:
-                            await child.close_messages()
-                        await asyncio.gather(*(child.task for child in self.children))
-
-                    try:
-                        await asyncio.wait_for(close_all(), timeout=5)
-                    except asyncio.TimeoutError as error:
-                        raise ShutdownError(
-                            "Timeout closing messages pump(s)"
-                        ) from None
-
-                self.children.clear()
+                driver.stop_application_mode()
             finally:
-                try:
-                    driver.stop_application_mode()
-                finally:
-                    loop.remove_signal_handler(signal.SIGINT)
+                loop.remove_signal_handler(signal.SIGINT)
 
     async def add(self, child: MessagePump) -> None:
         self.children.add(child)
         child.start_messages()
         await child.post_message(events.Created(sender=self))
 
+    async def remove(self, child: MessagePump) -> None:
+        self.children.remove(child)
+
+    async def shutdown(self):
+        driver = self._driver
+        driver.disable_input()
+
+        async def shutdown_procedure() -> None:
+            log.debug("1")
+            await self.stop_messages()
+            log.debug("2")
+            await self.view.stop_messages()
+            log.debug("3")
+            log.debug("4")
+            await self.remove(self.view)
+            if self.children:
+                log.debug("5")
+
+                async def close_all() -> None:
+                    for child in self.children:
+                        await child.close_messages(wait=False)
+                    await asyncio.gather(*(child.task for child in self.children))
+
+                try:
+                    await asyncio.wait_for(close_all(), timeout=5)
+                    log.debug("6")
+                except asyncio.TimeoutError as error:
+                    raise ShutdownError("Timeout closing messages pump(s)") from None
+                log.debug("7")
+
+            log.debug("8")
+            await self.view.close_messages()
+            log.debug("9")
+            await self.close_messages()
+            log.debug("10")
+
+        await asyncio.create_task(shutdown_procedure())
+
     def refresh(self) -> None:
         console = self.console
         try:
@@ -150,7 +172,7 @@ def refresh(self) -> None:
         except Exception:
             log.exception("refresh failed")
 
-    async def on_event(self, event: events.Event, priority: int) -> None:
+    async def on_event(self, event: events.Event) -> None:
         if isinstance(event, events.Key):
             key_action = self.KEYS.get(event.key, None)
             if key_action is not None:
@@ -160,7 +182,7 @@ async def on_event(self, event: events.Event, priority: int) -> None:
         if isinstance(event, events.InputEvent):
             await self.view.forward_input_event(event)
         else:
-            await super().on_event(event, priority)
+            await super().on_event(event)
 
     async def on_idle(self, event: events.Idle) -> None:
         await self.view.post_message(event)
@@ -215,7 +237,7 @@ async def on_mouse_scroll_down(self, event: events.MouseScrollUp) -> None:
         await self.view.post_message(event)
 
     async def action_quit(self) -> None:
-        await self.close_messages()
+        await self.shutdown()
 
     async def action_bang(self) -> None:
         1 / 0