259 lines
10 KiB
Python
259 lines
10 KiB
Python
"""Routes implementation.
|
|
|
|
Why this dispatcher exists
|
|
--------------------------
|
|
Home Assistant registers aiohttp routes on startup. Re-registering or removing routes at runtime
|
|
is awkward and error-prone (and can raise if routes already exist). This integration supports
|
|
multiple station push endpoints. To allow switching between them without touching the aiohttp
|
|
router, we register routes once and use this in-process dispatcher to decide which one is
|
|
currently enabled.
|
|
|
|
Important note:
|
|
- Each route stores a *bound method* handler (e.g. `coordinator.received_data`). That means the
|
|
route points to a specific coordinator instance. When the integration reloads, we must keep the
|
|
same coordinator instance or update the stored handler accordingly. Otherwise requests may go to
|
|
an old coordinator while entities listen to a new one (result: UI appears "frozen").
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Awaitable, Callable
|
|
from dataclasses import dataclass, field
|
|
import logging
|
|
from typing import Any
|
|
|
|
from aiohttp.web import AbstractRoute, Request, Response
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
Handler = Callable[[Request], Awaitable[Response]]
|
|
IngressObserver = Callable[[Request, bool, str | None], None]
|
|
|
|
|
|
@dataclass
|
|
class RouteInfo:
|
|
"""Route definition held by the dispatcher.
|
|
|
|
- `handler` is the real webhook handler (bound method).
|
|
- `fallback` is used when the route exists but is currently disabled.
|
|
"""
|
|
|
|
url_path: str
|
|
route: AbstractRoute
|
|
handler: Handler
|
|
enabled: bool = False
|
|
sticky: bool = False
|
|
|
|
fallback: Handler = field(default_factory=lambda: unregistered)
|
|
|
|
def __str__(self):
|
|
"""Return string representation."""
|
|
return f"RouteInfo(url_path={self.url_path}, route={self.route}, handler={self.handler}, enabled={self.enabled}, fallback={self.fallback})"
|
|
|
|
|
|
class Routes:
|
|
"""Simple route dispatcher.
|
|
|
|
We register aiohttp routes once and direct traffic to the currently enabled endpoint
|
|
using `switch_route`. This keeps route registration stable while still allowing the
|
|
integration to support multiple incoming push formats.
|
|
"""
|
|
|
|
def __init__(self) -> None:
|
|
"""Initialize dispatcher storage."""
|
|
self.routes: dict[str, RouteInfo] = {}
|
|
self._ingress_observer: IngressObserver | None = None
|
|
self.active: bool = True
|
|
|
|
def activate(self) -> None:
|
|
"""Allow registered routes to dispatch to their configured handlers."""
|
|
self.active = True
|
|
|
|
def deactivate(self) -> None:
|
|
"""Stop registered routes from dispatching to config-entry handlers.
|
|
|
|
The ingress observer is deliberately kept: a payload that arrives while the
|
|
entry is unloaded is exactly the kind of thing diagnostics needs to record,
|
|
and `HealthCoordinator.record_dispatch` is safe to call then - it only
|
|
publishes a snapshot to (no) listeners and tolerates missing runtime data.
|
|
The next setup repoints it at the new coordinator.
|
|
"""
|
|
self.active = False
|
|
|
|
def _resolve_route(self, request: Request) -> RouteInfo | None:
|
|
"""Find the matching RouteInfo for a request.
|
|
|
|
Two step lookup:
|
|
1) Find exact match using method:path (for fix routes)
|
|
2) Fallback to aiohttp resource canonical URL
|
|
works for routes with path parameter - as {webhook_id}
|
|
"""
|
|
|
|
key = f"{request.method}:{request.path}"
|
|
if key in self.routes:
|
|
return self.routes[key]
|
|
|
|
# Fallback to the aiohttp resource canonical URL (for routes with a path
|
|
# parameter such as {webhook_id}). Resolve defensively: a request without
|
|
# match_info/route/resource simply has no canonical match.
|
|
match_info = getattr(request, "match_info", None)
|
|
route = getattr(match_info, "route", None)
|
|
resource = getattr(route, "resource", None)
|
|
if resource is not None:
|
|
canonical_key = f"{request.method}:{resource.canonical}"
|
|
if canonical_key in self.routes:
|
|
return self.routes[canonical_key]
|
|
|
|
return None
|
|
|
|
def set_ecowitt_enabled(self, url_path: str, handler: Handler, enabled: bool) -> None:
|
|
"""Enable or disable the Ecowitt sticky route.
|
|
|
|
switch_route() does not involve sticky routes, so we need another
|
|
method for Ecowitt state at reload.
|
|
"""
|
|
|
|
for route in self.routes.values():
|
|
if route.url_path == url_path and route.sticky:
|
|
route.enabled = enabled
|
|
route.handler = handler if enabled else unregistered
|
|
_LOGGER.info(
|
|
"Ecowitt route %s %s",
|
|
route.url_path,
|
|
"enabled" if enabled else "disabled",
|
|
)
|
|
return
|
|
|
|
def rebind_handler(self, url_path: str, handler: Handler) -> None:
|
|
"""Repoint an always-on sticky route to a new handler after a reload.
|
|
|
|
Sticky routes (e.g. health) stay enabled across reloads, but their stored
|
|
handler is a bound method tied to a specific coordinator instance. When the
|
|
integration reloads, a new coordinator is created, so the handler must be
|
|
repointed - otherwise the route keeps calling the old (stale) instance.
|
|
|
|
Unlike `set_ecowitt_enabled`, this never changes `enabled`; it only rebinds
|
|
currently enabled sticky routes for `url_path`.
|
|
"""
|
|
|
|
for route in self.routes.values():
|
|
if route.url_path == url_path and route.sticky and route.enabled:
|
|
route.handler = handler
|
|
_LOGGER.debug("Rebound sticky route handler for %s", url_path)
|
|
return
|
|
|
|
def set_ingress_observer(self, observer: IngressObserver | None) -> None:
|
|
"""Set a callback notified for every incoming dispatcher request."""
|
|
self._ingress_observer = observer
|
|
|
|
async def dispatch(self, request: Request) -> Response:
|
|
"""Dispatch incoming request to either the enabled handler or a fallback."""
|
|
|
|
info = self._resolve_route(request)
|
|
|
|
if not info:
|
|
_LOGGER.debug("Route (%s):%s is not registered!", request.method, request.path)
|
|
if self._ingress_observer is not None:
|
|
self._ingress_observer(request, False, "route_not_registered")
|
|
return await unregistered(request)
|
|
|
|
if not self.active:
|
|
_LOGGER.debug("Route (%s):%s received while integration is not loaded.", request.method, request.path)
|
|
if self._ingress_observer is not None:
|
|
self._ingress_observer(request, False, "integration_unloaded")
|
|
return Response(text="Integration is not loaded.", status=503)
|
|
|
|
if self._ingress_observer is not None:
|
|
self._ingress_observer(
|
|
request,
|
|
info.enabled,
|
|
None if info.enabled else "route_disabled",
|
|
)
|
|
|
|
handler = info.handler if info.enabled else info.fallback
|
|
return await handler(request)
|
|
|
|
def switch_route(self, handler: Handler, url_path: str | None, *, enabled: bool = True) -> None:
|
|
"""Enable routes based on URL, disable all others. Leave sticky routes enabled.
|
|
|
|
When `enabled` is False (or url_path is None), all non-sticky (legacy) routes are disabled.
|
|
- used when only Ecowitt is active.
|
|
Sticky routes (health, ecowitt) are left untouched.
|
|
The aiohttp router stays untouched; we only flip which internal handler is active.
|
|
"""
|
|
for route in self.routes.values():
|
|
if route.sticky:
|
|
continue
|
|
|
|
if enabled and route.url_path == url_path:
|
|
_LOGGER.info(
|
|
"New coordinator to route: (%s):%s",
|
|
route.route.method,
|
|
route.url_path,
|
|
)
|
|
route.enabled = True
|
|
route.handler = handler
|
|
else:
|
|
route.enabled = False
|
|
route.handler = unregistered
|
|
|
|
def add_route(
|
|
self,
|
|
url_path: str,
|
|
route: AbstractRoute,
|
|
handler: Handler,
|
|
*,
|
|
enabled: bool = False,
|
|
sticky: bool = False,
|
|
) -> None:
|
|
"""Register a route in the dispatcher.
|
|
|
|
This does not register anything in aiohttp. It only stores routing metadata that
|
|
`dispatch` uses after aiohttp has routed the request by path.
|
|
"""
|
|
key = f"{route.method}:{url_path}"
|
|
self.routes[key] = RouteInfo(url_path, route=route, handler=handler, enabled=enabled, sticky=sticky)
|
|
_LOGGER.debug("Registered dispatcher for route (%s):%s", route.method, url_path)
|
|
|
|
def show_enabled(self) -> str:
|
|
"""Return a human-readable description of the currently enabled route."""
|
|
|
|
if not self.active:
|
|
return "No routes are enabled."
|
|
|
|
enabled_routes = {
|
|
f"Dispatcher enabled for ({route.route.method}):{route.url_path}, with handler: {route.handler}"
|
|
for route in self.routes.values()
|
|
if route.enabled
|
|
}
|
|
if not enabled_routes:
|
|
return "No routes are enabled."
|
|
return ", ".join(sorted(enabled_routes))
|
|
|
|
def path_enabled(self, url_path: str) -> bool:
|
|
"""Return whether any route registered for `url_path` is enabled."""
|
|
return self.active and any(route.enabled for route in self.routes.values() if route.url_path == url_path)
|
|
|
|
def snapshot(self) -> dict[str, Any]:
|
|
"""Return a compact routing snapshot for diagnostics."""
|
|
return {
|
|
key: {
|
|
"path": route.url_path,
|
|
"method": route.route.method,
|
|
"enabled": self.active and route.enabled,
|
|
"sticky": route.sticky,
|
|
}
|
|
for key, route in self.routes.items()
|
|
}
|
|
|
|
|
|
async def unregistered(request: Request) -> Response:
|
|
"""Fallback response for unknown/disabled routes.
|
|
|
|
This should normally never happen for correctly configured stations, but it provides
|
|
a clear error message when the station pushes to the wrong endpoint.
|
|
"""
|
|
_ = request
|
|
_LOGGER.debug("Received data to unregistered or disabled webhook.")
|
|
return Response(text="Unregistered webhook. Check your settings.", status=400)
|