more

Author: mxschmitt

playwright/_impl/_browser_context.py

@@ -196,6 +196,7 @@ def __init__(
             self.Events.Close, lambda context: self._closed_future.set_result(True)
         )
         self._close_reason: Optional[str] = None
+        self._har_routers: List[HarRouter] = []
         self._set_event_to_subscription_mapping(
             {
                 BrowserContext.Events.Console: "console",
@@ -219,8 +220,12 @@ def _on_page(self, page: Page) -> None:
 
     async def _on_route(self, route: Route) -> None:
         route._context = self
+        page = route.request._safe_page()
         route_handlers = self._routes.copy()
         for route_handler in route_handlers:
+            # If the page or the context was closed we stall all requests right away.
+            if (page and page._close_was_called) or self._close_was_called:
+                return
             if not route_handler.matches(route.request.url):
                 continue
             if route_handler not in self._routes:
@@ -238,7 +243,12 @@ async def _on_route(self, route: Route) -> None:
                     )
             if handled:
                 return
-        await route._internal_continue(is_internal=True)
+        try:
+            # If the page is closed or unrouteAll() was called without waiting and interception disabled,
+            # the method will throw an error - silence it.
+            await route._internal_continue(is_internal=True)
+        except Exception:
+            pass
 
     def _on_binding(self, binding_call: BindingCall) -> None:
         func = self._bindings.get(binding_call._initializer["name"])
@@ -363,18 +373,37 @@ async def route(
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
     ) -> None:
-        self._routes = list(
-            filter(
-                lambda r: r.matcher.match != url or (handler and r.handler != handler),
-                self._routes,
-            )
-        )
+        removed = []
+        remaining = []
+        for route in self._routes:
+            if route.matcher.match != url or (handler and route.handler != handler):
+                remaining.append(route)
+            else:
+                removed.append(route)
+        await self._unroute_internal(removed, remaining, "default")
+
+    async def _unroute_internal(
+        self,
+        removed: List[RouteHandler],
+        remaining: List[RouteHandler],
+        behavior: Literal["default", "ignoreErrors", "wait"] = None,
+    ) -> None:
+        self._routes = remaining
         await self._update_interception_patterns()
+        if behavior is None or behavior == "default":
+            return
+        await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
+
+    def _dispose_har_routers(self) -> None:
+        for router in self._har_routers:
+            router.dispose()
+        self._har_routers = []
 
     async def unroute_all(
         self, behavior: Literal["default", "ignoreErrors", "wait"] = None
     ) -> None:
-        pass
+        await self._unroute_internal(self._routes, [], behavior)
+        self._dispose_har_routers()
 
     async def _record_into_har(
         self,
@@ -426,6 +455,7 @@ async def route_from_har(
             not_found_action=notFound or "abort",
             url_matcher=url,
         )
+        self._har_routers.append(router)
         await router.add_context_route(self)
 
     async def _update_interception_patterns(self) -> None:
@@ -457,6 +487,7 @@ def _on_close(self) -> None:
         if self._browser:
             self._browser._contexts.remove(self)
 
+        self._dispose_har_routers()
         self.emit(BrowserContext.Events.Close, self)
 
     async def close(self, reason: str = None) -> None:

playwright/_impl/_har_router.py

@@ -102,16 +102,14 @@ async def add_context_route(self, context: "BrowserContext") -> None:
             url=self._options_url_match or "**/*",
             handler=lambda route, _: asyncio.create_task(self._handle(route)),
         )
-        context.once("close", lambda _: self._dispose())
 
     async def add_page_route(self, page: "Page") -> None:
         await page.route(
             url=self._options_url_match or "**/*",
             handler=lambda route, _: asyncio.create_task(self._handle(route)),
         )
-        page.once("close", lambda _: self._dispose())
 
-    def _dispose(self) -> None:
+    def dispose(self) -> None:
         asyncio.create_task(
             self._local_utils._channel.send("harClose", {"harId": self._har_id})
         )

playwright/_impl/_helper.py

@@ -31,6 +31,7 @@
     List,
     Optional,
     Pattern,
+    Set,
     TypeVar,
     Union,
     cast,
@@ -257,6 +258,15 @@ def monotonic_time() -> int:
     return math.floor(time.monotonic() * 1000)
 
 
+class RouteHandlerInvocation:
+    complete: "asyncio.Future"
+    route: "Route"
+
+    def __init__(self, complete: "asyncio.Future", route: "Route") -> None:
+        self.complete = complete
+        self.route = route
+
+
 class RouteHandler:
     def __init__(
         self,
@@ -270,11 +280,29 @@ def __init__(
         self._times = times if times else math.inf
         self._handled_count = 0
         self._is_sync = is_sync
+        self._ignore_exception = False
+        self._active_invocations: Set[RouteHandlerInvocation] = set()
 
     def matches(self, request_url: str) -> bool:
         return self.matcher.matches(request_url)
 
     async def handle(self, route: "Route") -> bool:
+        handler_invocation = RouteHandlerInvocation(
+            asyncio.get_running_loop().create_future(), route
+        )
+        self._active_invocations.add(handler_invocation)
+        try:
+            return await self._handle_internal(route)
+        except Exception as e:
+            # If the handler was stopped (without waiting for completion), we ignore all exceptions.
+            if self._ignore_exception:
+                return False
+            raise e
+        finally:
+            handler_invocation.complete.set_result(None)
+            self._active_invocations.remove(handler_invocation)
+
+    async def _handle_internal(self, route: "Route") -> bool:
         handled_future = route._start_handling()
         handler_task = []
 
@@ -297,6 +325,20 @@ def impl() -> None:
         [handled, *_] = await asyncio.gather(handled_future, *handler_task)
         return handled
 
+    async def stop(self, behavior: Literal["ignoreErrors", "wait"]) -> None:
+        # When a handler is manually unrouted or its page/context is closed we either
+        # - wait for the current handler invocations to finish
+        # - or do not wait, if the user opted out of it, but swallow all exceptions
+        #   that happen after the unroute/close.
+        if behavior == "ignoreErrors":
+            self._ignore_exception = True
+        else:
+            tasks = []
+            for activation in self._active_invocations:
+                if not activation.route._did_throw:
+                    tasks.append(activation.complete)
+            await asyncio.gather(*tasks)
+
     @property
     def will_expire(self) -> bool:
         return self._handled_count + 1 >= self._times

playwright/_impl/_network.py

@@ -267,6 +267,9 @@ def _target_closed_future(self) -> asyncio.Future:
             return asyncio.Future()
         return page._closed_or_crashed_future
 
+    def _safe_page(self) -> "Optional[Page]":
+        return cast("Frame", from_channel(self._initializer["frame"]))._page
+
 
 class Route(ChannelOwner):
     def __init__(
@@ -275,6 +278,7 @@ def __init__(
         super().__init__(parent, type, guid, initializer)
         self._handling_future: Optional[asyncio.Future["bool"]] = None
         self._context: "BrowserContext" = cast("BrowserContext", None)
+        self._did_throw = False
 
     def _start_handling(self) -> "asyncio.Future[bool]":
         self._handling_future = asyncio.Future()
@@ -298,17 +302,17 @@ def request(self) -> Request:
         return from_channel(self._initializer["request"])
 
     async def abort(self, errorCode: str = None) -> None:
-        self._check_not_handled()
-        await self._race_with_page_close(
-            self._channel.send(
-                "abort",
-                {
-                    "errorCode": errorCode,
-                    "requestUrl": self.request._initializer["url"],
-                },
+        await self._handle_route(
+            lambda: self._race_with_page_close(
+                self._channel.send(
+                    "abort",
+                    {
+                        "errorCode": errorCode,
+                        "requestUrl": self.request._initializer["url"],
+                    },
+                )
             )
         )
-        self._report_handled(True)
 
     async def fulfill(
         self,
@@ -320,7 +324,22 @@ async def fulfill(
         contentType: str = None,
         response: "APIResponse" = None,
     ) -> None:
-        self._check_not_handled()
+        await self._handle_route(
+            lambda: self._inner_fulfill(
+                status, headers, body, json, path, contentType, response
+            )
+        )
+
+    async def _inner_fulfill(
+        self,
+        status: int = None,
+        headers: Dict[str, str] = None,
+        body: Union[str, bytes] = None,
+        json: Any = None,
+        path: Union[str, Path] = None,
+        contentType: str = None,
+        response: "APIResponse" = None,
+    ) -> None:
         params = locals_to_params(locals())
 
         if json is not None:
@@ -375,7 +394,15 @@ async def fulfill(
         params["requestUrl"] = self.request._initializer["url"]
 
         await self._race_with_page_close(self._channel.send("fulfill", params))
-        self._report_handled(True)
+
+    async def _handle_route(self, callback: Callable) -> None:
+        self._check_not_handled()
+        try:
+            await callback()
+            self._report_handled(True)
+        except Exception as e:
+            self._did_throw = True
+            raise e
 
     async def fetch(
         self,
@@ -418,10 +445,12 @@ async def continue_(
         postData: Union[Any, str, bytes] = None,
     ) -> None:
         overrides = cast(FallbackOverrideParameters, locals_to_params(locals()))
-        self._check_not_handled()
-        self.request._apply_fallback_overrides(overrides)
-        await self._internal_continue()
-        self._report_handled(True)
+
+        async def _inner() -> None:
+            self.request._apply_fallback_overrides(overrides)
+            await self._internal_continue()
+
+        return await self._handle_route(_inner)
 
     def _internal_continue(
         self, is_internal: bool = False
@@ -458,11 +487,11 @@ async def continue_route() -> None:
         return continue_route()
 
     async def _redirected_navigation_request(self, url: str) -> None:
-        self._check_not_handled()
-        await self._race_with_page_close(
-            self._channel.send("redirectNavigationRequest", {"url": url})
+        await self._handle_route(
+            lambda: self._race_with_page_close(
+                self._channel.send("redirectNavigationRequest", {"url": url})
+            )
         )
-        self._report_handled(True)
 
     async def _race_with_page_close(self, future: Coroutine) -> None:
         fut = asyncio.create_task(future)

playwright/_impl/_page.py

@@ -152,6 +152,8 @@ def __init__(
         self._video: Optional[Video] = None
         self._opener = cast("Page", from_nullable_channel(initializer.get("opener")))
         self._close_reason: Optional[str] = None
+        self._close_was_called = False
+        self._har_routers: List[HarRouter] = []
 
         self._channel.on(
             "bindingCall",
@@ -238,6 +240,9 @@ async def _on_route(self, route: Route) -> None:
         route._context = self.context
         route_handlers = self._routes.copy()
         for route_handler in route_handlers:
+            # If the page was closed we stall all requests right away.
+            if self._close_was_called or self.context._close_was_called:
+                return
             if not route_handler.matches(route.request.url):
                 continue
             if route_handler not in self._routes:
@@ -274,6 +279,7 @@ def _on_close(self) -> None:
             self._browser_context._pages.remove(self)
         if self in self._browser_context._background_pages:
             self._browser_context._background_pages.remove(self)
+        self._dispose_har_routers()
         self.emit(Page.Events.Close, self)
 
     def _on_crash(self) -> None:
@@ -587,18 +593,42 @@ async def route(
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
     ) -> None:
-        self._routes = list(
-            filter(
-                lambda r: r.matcher.match != url or (handler and r.handler != handler),
-                self._routes,
+        removed = []
+        remaining = []
+        for route in self._routes:
+            if route.matcher.match != url or (handler and route.handler != handler):
+                remaining.append(route)
+            else:
+                removed.append(route)
+        await self._unroute_internal(removed, remaining, "default")
+
+    async def _unroute_internal(
+        self,
+        removed: List[RouteHandler],
+        remaining: List[RouteHandler],
+        behavior: Literal["default", "ignoreErrors", "wait"] = None,
+    ) -> None:
+        self._routes = remaining
+        await self._update_interception_patterns()
+        if behavior is None or behavior == "default":
+            return
+        await asyncio.gather(
+            *map(
+                lambda route: route.stop(behavior),  # type: ignore
+                removed,
             )
         )
-        await self._update_interception_patterns()
+
+    def _dispose_har_routers(self) -> None:
+        for router in self._har_routers:
+            router.dispose()
+        self._har_routers = []
 
     async def unroute_all(
         self, behavior: Literal["default", "ignoreErrors", "wait"] = None
     ) -> None:
-        pass
+        await self._unroute_internal(self._routes, [], behavior)
+        self._dispose_har_routers()
 
     async def route_from_har(
         self,
@@ -624,6 +654,7 @@ async def route_from_har(
             not_found_action=notFound or "abort",
             url_matcher=url,
         )
+        self._har_routers.append(router)
         await router.add_page_route(self)
 
     async def _update_interception_patterns(self) -> None:
@@ -675,6 +706,7 @@ async def title(self) -> str:
 
     async def close(self, runBeforeUnload: bool = None, reason: str = None) -> None:
         self._close_reason = reason
+        self._close_was_called = True
         try:
             await self._channel.send("close", locals_to_params(locals()))
             if self._owned_context: