chore(asyncio): simplify cancelled-startup teardown

- reuse __aexit__ for teardown when __aenter__ fails or is cancelled,
  mirroring the sync context manager
- move _stopped_future and wait_until_stopped() into the Transport base,
  deleting both subclass copies
- reuse request_stop() when connect() finishes after a stop request
- skip sending __abort__ over a closed connection

Author: yury-s

playwright/_impl/_connection.py

@@ -461,16 +461,17 @@ def _send_message_to_server(
     async def _abort(
         self, object: ChannelOwner, callback: ProtocolCallback, reason: str
     ) -> None:
-        try:
-            self._transport.send(
-                {
-                    "guid": object._guid,
-                    "method": "__abort__",
-                    "params": {"id": callback.id, "reason": reason},
-                }
-            )
-        except (Error, OSError):
-            pass
+        if not self._closed_error:
+            try:
+                self._transport.send(
+                    {
+                        "guid": object._guid,
+                        "method": "__abort__",
+                        "params": {"id": callback.id, "reason": reason},
+                    }
+                )
+            except (Error, OSError):
+                pass
         try:
             await asyncio.wait(
                 {
@@ -486,11 +487,9 @@ async def _abort(
             # retrieved' errors.
             if not callback.future.done():
                 callback.future.cancel()
-            elif not callback.future.cancelled():
-                callback.future.exception()
-            error_future = self._transport.on_error_future
-            if error_future.done() and not error_future.cancelled():
-                error_future.exception()
+            for future in (callback.future, self._transport.on_error_future):
+                if future.done() and not future.cancelled():
+                    future.exception()
 
     def dispatch(self, msg: ParsedMessagePayload) -> None:
         if self._closed_error:

playwright/_impl/_json_pipe.py

@@ -42,12 +42,7 @@ def dispose(self) -> None:
         self.on_error_future.cancel()
         self._stopped_future.cancel()
 
-    async def wait_until_stopped(self) -> None:
-        await self._stopped_future
-
     async def connect(self) -> None:
-        self._stopped_future: asyncio.Future = asyncio.Future()
-
         def handle_message(message: Dict) -> None:
             if self._stop_requested:
                 return

playwright/_impl/_transport.py

@@ -50,6 +50,7 @@ def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
         self._loop = loop
         self.on_message: Callable[[ParsedMessagePayload], None] = lambda _: None
         self.on_error_future: asyncio.Future = loop.create_future()
+        self._stopped_future: asyncio.Future = loop.create_future()
 
     @abstractmethod
     def request_stop(self) -> None:
@@ -58,9 +59,8 @@ def request_stop(self) -> None:
     def dispose(self) -> None:
         pass
 
-    @abstractmethod
     async def wait_until_stopped(self) -> None:
-        pass
+        await self._stopped_future
 
     @abstractmethod
     async def connect(self) -> None:
@@ -93,7 +93,6 @@ def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
         super().__init__(loop)
         self._stopped = False
         self._output: Optional[asyncio.StreamWriter] = None
-        self._stopped_future: asyncio.Future = loop.create_future()
 
     def request_stop(self) -> None:
         self._stopped = True
@@ -102,9 +101,6 @@ def request_stop(self) -> None:
         if self._output:
             self._output.close()
 
-    async def wait_until_stopped(self) -> None:
-        await self._stopped_future
-
     async def connect(self) -> None:
         try:
             # For pyinstaller and Nuitka
@@ -131,14 +127,13 @@ async def connect(self) -> None:
                 startupinfo=startupinfo,
             )
         except Exception as exc:
-            if not self._stopped_future.done():
-                self._stopped_future.set_result(None)
+            self._stopped_future.set_result(None)
             self.on_error_future.set_exception(exc)
             raise exc
 
         self._output = self._proc.stdin
-        if self._stopped and self._output:
-            self._output.close()
+        if self._stopped:
+            self.request_stop()
 
     async def run(self) -> None:
         assert self._proc.stdout

playwright/async_api/_context_manager.py

@@ -42,16 +42,15 @@ async def __aenter__(self) -> AsyncPlaywright:
                 {self._connection._transport.on_error_future, playwright_future},
                 return_when=asyncio.FIRST_COMPLETED,
             )
-        except asyncio.CancelledError:
-            # Cancelled while connecting - stop the driver process and the
-            # background tasks, otherwise they keep running with no owner.
             if not playwright_future.done():
                 playwright_future.cancel()
-            await self._connection.stop_async()
-            raise
-        if not playwright_future.done():
+            playwright = AsyncPlaywright(next(iter(done)).result())
+        except BaseException:
+            # Startup failed or was cancelled - stop the driver process and the
+            # background tasks, otherwise they keep running with no owner.
             playwright_future.cancel()
-        playwright = AsyncPlaywright(next(iter(done)).result())
+            await self.__aexit__()
+            raise
         playwright.stop = self.__aexit__  # type: ignore
         return playwright
 

tests/async/test_asyncio.py

@@ -174,7 +174,7 @@ async def main(delay):
                     pass
 
 
-            for delay in (0.001, 0.01, 0.05, 0.1, 0.5):
+            for delay in (0.001, 0.05, 0.5):
                 asyncio.run(main(delay))
             print("DONE", flush=True)
             """