Alternative to passing router to the application?

[mcfletch]

Describe the bug

I have an application which can discover new plugins at run time (think plugging new hardware into a generic backplane). As such, the routing of the application can change based on which hardware has been inserted after the application is running. There are lots of long-running (websocket) processes, so I don't want to restart the application just to allow the new endpoints to be registered.

My solution so far has been to create a router facade which tracks each registered endpoint and generates a new standard router with those endpoints when there's an update to the set of plugged in hardware and swaps in the router to handle new requests without cycling the application or listening port. That works fine, but apparently the Application's router argument is now deprecated.

Is there a recommended solution for those who do use custom routers with aiohttp? Should we sub-class Application to override the class used to create the router?

To Reproduce

1. Attempt to pass router to the Application
2. Deprecation warning is generated

Expected behavior

There would ideally be a straightforward way for those who have coded custom routers to be able to use them with the newer releases of aiohttp.

Logs/tracebacks

DeprecationWarning: router argument is deprecated

Python Version

$ python --version
Python 3.11.14

aiohttp Version

$ python -m pip show aiohttp
Name: aiohttp
Version: 3.13.1
Summary: Async http client/server framework (asyncio)
Home-page: https://github.com/aio-libs/aiohttp
Author: 
Author-email: 
License: Apache-2.0 AND MIT
Location: /home/mcfletch/atx-dev/vada-devsetup/.venv/lib/python3.11/site-packages
Requires: aiohappyeyeballs, aiosignal, attrs, frozenlist, multidict, propcache, yarl
Required-by: aiohttp-swagger, aiosseclient

multidict Version

$ python -m pip show multidict
Name: multidict
Version: 6.7.0
Summary: multidict implementation
Home-page: https://github.com/aio-libs/multidict
Author: Andrew Svetlov
Author-email: andrew.svetlov@gmail.com
License: Apache License 2.0
Location: /home/mcfletch/atx-dev/vada-devsetup/.venv/lib/python3.11/site-packages
Requires: 
Required-by: aiohttp, grpclib, yarl

propcache Version

$ python -m pip show propcache
Name: propcache
Version: 0.4.1
Summary: Accelerated property cache
Home-page: https://github.com/aio-libs/propcache
Author: Andrew Svetlov
Author-email: andrew.svetlov@gmail.com
License: Apache-2.0
Location: /home/mcfletch/atx-dev/vada-devsetup/.venv/lib/python3.11/site-packages
Requires: 
Required-by: aiohttp, yarl

yarl Version

$ python -m pip show yarl
Name: yarl
Version: 1.22.0
Summary: Yet another URL library
Home-page: https://github.com/aio-libs/yarl
Author: Andrew Svetlov
Author-email: andrew.svetlov@gmail.com
License: Apache-2.0
Location: /home/mcfletch/atx-dev/vada-devsetup/.venv/lib/python3.11/site-packages
Requires: idna, multidict, propcache
Required-by: aiohttp

OS

Debian, Ubuntu, Yocto

Related component

Server

Additional context

No response

Code of Conduct

• I agree to follow the aio-libs Code of Conduct

[Dreamsorcerer]

The only foolproof solution currently would be to create an endpoint which captures all URL paths and then have that endpoint switch function dynamically.

This is not the first time this feature has been asked for, so I think we'll want to revisit the possibility of dynamically adding routes. The problem is that the routing information needs to be recalculated each time it's changed, which could block the server for a couple of seconds or similar. So, we need to think about it for v4.

[rodrigobnogueira]

Something like https://github.com/bitrate16/aiohttp-dynamic ?

[Dreamsorcerer]

That's basically doing what I suggested by adding an endpoint and handling the routing within that endpoint. Pro: It provides the router API from aiohttp for convenience, Con: It copies large amounts of aiohttp code and may become out-of-sync.

It's not something that is useful to look at when planning this feature in v4.

[rodrigobnogueira]

Probably a hack, but:

One approach that works well for this use case is a server-side middleware that intercepts requests before the built-in (frozen) router gets a chance to handle them.

The idea is the middleware maintains its own list of dynamic routes. On each request, it checks the dynamic routes first. If there's a match, it dispatches to the dynamic handler directly. If not, it falls through to the normal router (or 404). Since middleware runs around the handler pipeline, this works without touching the frozen router at all.

[rodrigobnogueira]

The main limitation is that dynamic routes won't be visible to app.router.url_for()

[rodrigobnogueira]

class DynamicRouterMiddleware:
    def __init__(self):
        self._routes: dict[str, list[tuple[re.Pattern, Handler, str]]] = {}

    def add_route(self, method: str, path: str, handler: Handler) -> None:
        regex = re.compile("^" + re.sub(r"\{(\w+)\}", r"(?P<\1>[^/]+)", path) + "$")
        self._routes.setdefault(method.upper(), []).append((regex, handler, path))

    def remove_route(self, method: str, path: str) -> bool:
        entries = self._routes.get(method.upper(), [])
        for i, (_, _, orig) in enumerate(entries):
            if orig == path:
                entries.pop(i)
                return True
        return False

    async def __call__(self, request, handler):
        for regex, dyn_handler, _ in self._routes.get(request.method, []):
            match = regex.match(request.path)
            if match:
                request.match_info.update(match.groupdict())
                return await dyn_handler(request)
        return await handler(request)

Usage:

dynamic = DynamicRouterMiddleware()
app = web.Application(middlewares=[dynamic])
app.router.add_get("/health", health_handler)  # normal static route

# Add/remove at any time — even after web.run_app()
dynamic.add_route("GET", "/hardware/{device_id}", device_handler)
dynamic.remove_route("GET", "/hardware/{device_id}")

[rodrigobnogueira]

@mcfletch , you can check this working example here: https://github.com/rodrigobnogueira/aiohttp/blob/dynamic-router-middleware-example/examples/dynamic_router_middleware.py