Unify server dispatch through handler.handle()

Both HTTP/1.1 and HTTP/2 workers now use a single handler.handle()
call instead of separate sync/async dispatch paths. The handler
manages signals and async view detection internally.

Author: davegaeddert

plain/plain/server/http/h2handler.py

@@ -15,7 +15,6 @@
 import h2.events
 import h2.exceptions
 
-from plain import signals
 from plain.http import AsyncStreamingResponse, FileResponse, StreamingResponse
 from plain.http import Request as HttpRequest
 
@@ -502,7 +501,6 @@ async def _async_handle_stream(
     stream: H2Stream,
 ) -> None:
     """Process a single completed HTTP/2 stream as an async task."""
-    loop = asyncio.get_running_loop()
     request_start = datetime.now()
 
     try:
@@ -515,26 +513,7 @@ async def _async_handle_stream(
         return
 
     try:
-        signals.request_started.send(
-            sender=state.handler.__class__, request=http_request
-        )
-
-        # Detect async views — resolve URL in executor to avoid blocking event loop
-        def _check_async() -> bool:
-            return hasattr(
-                state.handler, "is_async_view"
-            ) and state.handler.is_async_view(http_request)
-
-        is_async = await loop.run_in_executor(state.executor, _check_async)
-
-        if is_async:
-            http_response = await state.handler.get_response_async(
-                http_request, state.executor
-            )
-        else:
-            http_response = await loop.run_in_executor(
-                state.executor, state.handler.get_response, http_request
-            )
+        http_response = await state.handler.handle(http_request, state.executor)
 
         try:
             if stream.stream_id in state.reset_streams:

plain/plain/server/util.py

@@ -185,7 +185,7 @@ def make_fail_handler(msg: str | bytes) -> Any:
     msg = to_bytestring(msg)
 
     class FailHandler:
-        def get_response(self, request: Any) -> Any:
+        async def handle(self, request: Any, executor: Any) -> Any:
             from plain.http import Response
 
             return Response(msg, status_code=500, content_type="text/plain")

plain/plain/server/workers/thread.py

@@ -29,7 +29,6 @@
 from types import FrameType
 from typing import TYPE_CHECKING, Any
 
-from plain import signals
 from plain.internal.reloader import Reloader
 
 from .. import http, sock, util
@@ -317,26 +316,9 @@ async def _handle_connection(self, conn: TConn) -> None:
 
                 req, http_request, resp, request_start = parse_result
 
-                # Detect async views (fast, safe on event loop).
-                # FailHandler (from make_fail_handler) doesn't have this method.
-                is_async = hasattr(
-                    self.handler, "is_async_view"
-                ) and self.handler.is_async_view(http_request)
-
-                if is_async:
-                    keepalive = await self._dispatch_async(
-                        req, conn, http_request, resp, request_start
-                    )
-                else:
-                    keepalive = await loop.run_in_executor(
-                        self.tpool,
-                        self._dispatch_sync,
-                        req,
-                        conn,
-                        http_request,
-                        resp,
-                        request_start,
-                    )
+                keepalive = await self._dispatch(
+                    req, conn, http_request, resp, request_start
+                )
 
                 if not keepalive or not self.alive:
                     break
@@ -627,44 +609,18 @@ def _handle_dispatch_error(
             self.handle_error(req, conn.sock, conn.client, exc)
         return False
 
-    def _dispatch_sync(
-        self,
-        req: Any,
-        conn: TConn,
-        http_request: Any,
-        resp: Response,
-        request_start: datetime,
-    ) -> bool:
-        """Sync dispatch: signal + full middleware pipeline + write response."""
-        try:
-            signals.request_started.send(sender=self.__class__, request=http_request)
-            http_response = self.handler.get_response(http_request)
-            return self._finish_request(req, resp, http_response, request_start)
-        except Exception as exc:
-            return self._handle_dispatch_error(req, resp, conn, exc)
-
-    async def _dispatch_async(
+    async def _dispatch(
         self,
         req: Any,
         conn: TConn,
         http_request: Any,
         resp: Response,
         request_start: datetime,
     ) -> bool:
-        """Async dispatch: middleware in thread pool, async view on event loop."""
+        """Dispatch a request through the handler and write the response."""
         loop = asyncio.get_running_loop()
         try:
-            # Send signal in thread pool (handlers may do sync work)
-            await loop.run_in_executor(
-                self.tpool,
-                lambda: signals.request_started.send(
-                    sender=self.__class__, request=http_request
-                ),
-            )
-            # Async middleware pipeline + view
-            http_response = await self.handler.get_response_async(
-                http_request, self.tpool
-            )
+            http_response = await self.handler.handle(http_request, self.tpool)
 
             # Check for async streaming response (SSE, etc.)
             from plain.http import AsyncStreamingResponse