finish up flask conversion

Author: rmorshea

src/idom/server/any.py

@@ -4,12 +4,11 @@
 import warnings
 import webbrowser
 from importlib import import_module
-from typing import Any, Awaitable, Iterator, TypeVar, runtime_checkable
-
-from typing_extensions import Protocol
+from typing import Any, Awaitable, Iterator
 
 from idom.types import ComponentConstructor
 
+from .types import ServerImplementation
 from .utils import find_available_port
 
 
@@ -36,23 +35,16 @@ def run(
         stacklevel=2,
     )
 
-    try:
-        implementation = next(all_implementations())
-    except StopIteration:
-        raise RuntimeError(  # pragma: no cover
-            f"Found no built-in server implementation installed {SUPPORTED_PACKAGES}"
-        )
-
-    app = implementation.create_development_app()
-    implementation.configure(app, component)
+    app = create_development_app()
+    configure(app, component)
 
     coros: list[Awaitable] = []
 
     host = host
     port = port or find_available_port(host)
     started = asyncio.Event()
 
-    coros.append(implementation.serve_development_app(app, host, port, started))
+    coros.append(serve_development_app(app, host, port, started))
 
     if open_browser:
 
@@ -66,55 +58,51 @@ async def _open_browser_after_server() -> None:
 
 
 def configure(app: Any, component: ComponentConstructor) -> None:
+    """Configure the given app instance to display the given component"""
     return get_implementation().configure(app, component)
 
 
 def create_development_app() -> Any:
+    """Create an application instance for development purposes"""
     return get_implementation().create_development_app()
 
 
 async def serve_development_app(
     app: Any, host: str, port: int, started: asyncio.Event
 ) -> None:
+    """Run an application using a development server"""
     return await get_implementation().serve_development_app(app, host, port, started)
 
 
-def get_implementation() -> Implementation:
+def get_implementation() -> ServerImplementation:
     """Get the first available server implementation"""
+    if _DEFAULT_IMPLEMENTATION is not None:
+        return _DEFAULT_IMPLEMENTATION
+
     try:
-        return next(all_implementations())
+        implementation = next(all_implementations())
     except StopIteration:
         raise RuntimeError("No built-in server implementation installed.")
+    else:
+        global _DEFAULT_IMPLEMENTATION
+        _DEFAULT_IMPLEMENTATION = implementation
+        return implementation
+
 
+_DEFAULT_IMPLEMENTATION: ServerImplementation | None = None
 
-def all_implementations() -> Iterator[Implementation]:
+
+def all_implementations() -> Iterator[ServerImplementation]:
     """Yield all available server implementations"""
     for name in SUPPORTED_PACKAGES:
         try:
             module = import_module(f"idom.server.{name}")
         except ImportError:  # pragma: no cover
             continue
 
-        if not isinstance(module, Implementation):
-            raise TypeError(f"{module.__name__!r} is an invalid implementation")
+        if not isinstance(module, ServerImplementation):
+            raise TypeError(  # pragma: no cover
+                f"{module.__name__!r} is an invalid implementation"
+            )
 
         yield module
-
-
-_App = TypeVar("_App")
-
-
-@runtime_checkable
-class Implementation(Protocol):
-    """Common interface for IDOM's builti-in server implementations"""
-
-    def configure(self, app: _App, component: ComponentConstructor) -> None:
-        """Configure the given app instance to display the given component"""
-
-    def create_development_app(self) -> _App:
-        """Create an application instance for development purposes"""
-
-    async def serve_development_app(
-        self, app: _App, host: str, port: int, started: asyncio.Event
-    ) -> None:
-        """Run an application using a development server"""

src/idom/server/flask.py

@@ -13,26 +13,25 @@
 from flask import Blueprint, Flask, redirect, request, send_from_directory, url_for
 from flask_cors import CORS
 from flask_sockets import Sockets
-from gevent import pywsgi
-from geventwebsocket.handler import WebSocketHandler
 from geventwebsocket.websocket import WebSocket
 from typing_extensions import TypedDict
+from werkzeug.serving import ThreadedWSGIServer
 
 import idom
 from idom.config import IDOM_DEBUG_MODE, IDOM_WEB_MODULES_DIR
 from idom.core.dispatcher import dispatch_single_view
 from idom.core.layout import LayoutEvent, LayoutUpdate
 from idom.core.types import ComponentConstructor, ComponentType
 
-from .utils import CLIENT_BUILD_DIR, threaded, wait_on_event
+from .utils import CLIENT_BUILD_DIR
 
 
 logger = logging.getLogger(__name__)
 
 
 def configure(
     app: Flask, component: ComponentConstructor, options: Options | None = None
-) -> FlaskServer:
+) -> None:
     """Return a :class:`FlaskServer` where each client has its own state.
 
     Implements the :class:`~idom.server.proto.ServerFactory` protocol
@@ -47,17 +46,45 @@ def configure(
     _setup_common_routes(blueprint, options)
     _setup_single_view_dispatcher_route(app, options, component)
     app.register_blueprint(blueprint)
-    return FlaskServer(app)
 
 
 def create_development_app() -> Flask:
+    """Create an application instance for development purposes"""
     return Flask(__name__)
 
 
 async def serve_development_app(
     app: Flask, host: str, port: int, started: asyncio.Event
 ) -> None:
-    ...
+    """Run an application using a development server"""
+    loop = asyncio.get_event_loop()
+
+    @app.before_first_request
+    def set_started():
+        loop.call_soon_threadsafe(started.set)
+
+    server = ThreadedWSGIServer(host, port, app)
+
+    stopped = asyncio.Event()
+
+    def run_server():
+        try:
+            server.serve_forever()
+        finally:
+            loop.call_soon_threadsafe(stopped.set)
+
+    thread = Thread(target=run_server, daemon=True)
+
+    try:
+        await stopped.wait()
+    finally:
+        # we may have exitted because this task was cancelled
+        server.shutdown()
+        # the thread should eventually join
+        thread.join(timeout=3)
+        # just double check it happened
+        if thread.is_alive():
+            raise RuntimeError("Failed to shutdown server.")
 
 
 class Options(TypedDict, total=False):
@@ -85,52 +112,6 @@ class Options(TypedDict, total=False):
     """The URL prefix where IDOM resources will be served from"""
 
 
-class FlaskServer:
-    """A thin wrapper for running a Flask application
-
-    See :class:`idom.server.proto.Server` for more info
-    """
-
-    _wsgi_server: pywsgi.WSGIServer
-
-    def __init__(self, app: Flask) -> None:
-        self.app = app
-        self._did_start = ThreadEvent()
-
-        @app.before_first_request
-        def server_did_start() -> None:
-            self._did_start.set()
-
-    def run(self, host: str, port: int, *args: Any, **kwargs: Any) -> None:
-        if IDOM_DEBUG_MODE.current:
-            logging.basicOptions(level=logging.DEBUG)  # pragma: no cover
-        logger.info(f"Running at http://{host}:{port}")
-        self._wsgi_server = _StartCallbackWSGIServer(
-            self._did_start.set,
-            (host, port),
-            self.app,
-            *args,
-            handler_class=WebSocketHandler,
-            **kwargs,
-        )
-        self._wsgi_server.serve_forever()
-
-    run_in_thread = threaded(run)
-
-    def wait_until_started(self, timeout: Optional[float] = 3.0) -> None:
-        wait_on_event(f"start {self.app}", self._did_start, timeout)
-
-    def stop(self, timeout: Optional[float] = 3.0) -> None:
-        try:
-            server = self._wsgi_server
-        except AttributeError:  # pragma: no cover
-            raise RuntimeError(
-                f"Application is not running or was not started by {self}"
-            )
-        else:
-            server.stop(timeout)
-
-
 def _setup_options(options: Options | None) -> Options:
     return {
         "url_prefix": "",
@@ -273,25 +254,6 @@ class _DispatcherThreadInfo(NamedTuple):
     async_recv_queue: "AsyncQueue[LayoutEvent]"
 
 
-class _StartCallbackWSGIServer(pywsgi.WSGIServer):  # type: ignore
-    def __init__(
-        self, before_first_request: Callable[[], None], *args: Any, **kwargs: Any
-    ) -> None:
-        self._before_first_request_callback = before_first_request
-        super().__init__(*args, **kwargs)
-
-    def update_environ(self) -> None:
-        """
-        Called before the first request is handled to fill in WSGI environment values.
-
-        This includes getting the correct server name and port.
-        """
-        super().update_environ()
-        # BUG: https://github.com/nedbat/coveragepy/issues/1012
-        # Coverage isn't able to support concurrency coverage for both threading and gevent
-        self._before_first_request_callback()  # pragma: no cover
-
-
 def _join_url_paths(*args: str) -> str:
     # urllib.parse.urljoin performs more logic than is needed. Thus we need a util func
     # to join paths as if they were POSIX paths.

src/idom/server/types.py

@@ -0,0 +1,25 @@
+import asyncio
+from typing import Callable, TypeVar
+
+from typing_extensions import Protocol, runtime_checkable
+
+from idom.core.types import ComponentType
+
+
+_App = TypeVar("_App")
+
+
+@runtime_checkable
+class ServerImplementation(Protocol):
+    """Common interface for IDOM's builti-in server implementations"""
+
+    def configure(self, app: _App, component: Callable[[], ComponentType]) -> None:
+        """Configure the given app instance to display the given component"""
+
+    def create_development_app(self) -> _App:
+        """Create an application instance for development purposes"""
+
+    async def serve_development_app(
+        self, app: _App, host: str, port: int, started: asyncio.Event
+    ) -> None:
+        """Run an application using a development server"""

src/idom/server/utils.py

@@ -1,60 +1,13 @@
-import asyncio
 import socket
-import time
 from contextlib import closing
-from functools import wraps
 from pathlib import Path
-from threading import Event, Thread
-from typing import Any, Callable, Optional
-
-from typing_extensions import ParamSpec
 
 import idom
 
 
 CLIENT_BUILD_DIR = Path(idom.__file__).parent / "client"
 
 
-_FuncParams = ParamSpec("_FuncParams")
-
-
-def threaded(function: Callable[_FuncParams, None]) -> Callable[_FuncParams, Thread]:
-    @wraps(function)
-    def wrapper(*args: Any, **kwargs: Any) -> Thread:
-        def target() -> None:
-            asyncio.set_event_loop(asyncio.new_event_loop())
-            function(*args, **kwargs)
-
-        thread = Thread(target=target, daemon=True)
-        thread.start()
-
-        return thread
-
-    return wrapper
-
-
-def wait_on_event(description: str, event: Event, timeout: Optional[float]) -> None:
-    if not event.wait(timeout):
-        raise TimeoutError(f"Did not {description} within {timeout} seconds")
-
-
-def poll(
-    description: str,
-    frequency: float,
-    timeout: Optional[float],
-    function: Callable[[], bool],
-) -> None:
-    if timeout is not None:
-        expiry = time.time() + timeout
-        while not function():
-            if time.time() > expiry:
-                raise TimeoutError(f"Did not {description} within {timeout} seconds")
-            time.sleep(frequency)
-    else:
-        while not function():
-            time.sleep(frequency)
-
-
 def find_available_port(
     host: str,
     port_min: int = 8000,

src/idom/types.py

@@ -21,7 +21,7 @@
     VdomDict,
     VdomJson,
 )
-from .server.types import ServerFactory, ServerType
+from .server.types import ServerImplementation
 
 
 __all__ = [
@@ -40,6 +40,5 @@
     "VdomChildren",
     "VdomDict",
     "VdomJson",
-    "ServerFactory",
-    "ServerType",
+    "ServerImplementation",
 ]