hermes-agent/gateway/platforms/tcp_site.py
ethernet cbb9660c2c Merge remote-tracking branch 'origin/main' into ethie/pm-clean
# Conflicts:
#	hermes_cli/plugin_python_deps.py
2026-09-22 23:08:39 -04:00

64 lines
3 KiB
Python

"""Bind an aiohttp ``TCPSite`` for the HTTP-serving adapters (webhook, api_server): exclusive on macOS,
yet able to rebind over a lingering TIME_WAIT socket right after a gateway restart."""
from __future__ import annotations
import asyncio
import errno
import logging
import socket
import sys
from typing import TYPE_CHECKING, Optional
if TYPE_CHECKING:
from aiohttp import web
from gateway.platforms.shared_ingress import is_wildcard_host
logger = logging.getLogger(__name__)
def has_live_listener(host: str, port: int) -> bool:
"""Blocking probe: True when something accepts connections on ``host:port``. Refused = nobody listens;
any other failure (timeout, unroutable) is treated as live so the caller stays exclusive."""
try:
with socket.create_connection((host, port), timeout=1.0):
return True
except ConnectionRefusedError:
return False
except OSError:
return True
async def start_tcp_site(runner: web.BaseRunner, host: Optional[str], port: int, *, log_tag: str) -> web.TCPSite:
"""Bind ``host:port`` on ``runner`` and return the started site; raises OSError when unavailable.
SO_REUSEADDR: on macOS (BSD) two wildcard/specific sockets can silently split traffic while
both report success → disable. On Linux it only permits rebinding past TIME_WAIT (a quick
restart would otherwise fail to bind for ~60s) → keep the default.
The macOS exclusive bind also refuses the port while a server-side TIME_WAIT socket lingers
(2*MSL = 30s after the previous gateway closed a connection first — its shutdown, or any
``Connection: close`` request), so a ``/restart`` re-binding within seconds failed with
EADDRINUSE although nobody was listening. Preventing the TIME_WAIT at close time (SO_LINGER 0)
would reset in-flight senders and misses the per-request case, hence the bind-side retry: for an
explicit host, ``has_live_listener`` refused proves the address is free (the kernel still
rejects an exact duplicate even with SO_REUSEADDR, and a foreign wildcard listener answers the
probe), so one retry with reuse_address=True is safe. A wildcard host keeps the strict path: a
foreign listener on a non-loopback interface could not be probed, so it must keep winning."""
from aiohttp import web
exclusive = sys.platform == "darwin"
site = web.TCPSite(runner, host, port, reuse_address=False if exclusive else None)
try:
await site.start()
except OSError as exc:
if not exclusive or exc.errno != errno.EADDRINUSE or is_wildcard_host(host):
raise
if await asyncio.to_thread(has_live_listener, host, port):
raise
await site.stop() # aiohttp registers a site before binding: drop the dead one from the runner
logger.info("[%s] %s:%d busy without a live listener (TIME_WAIT from the previous gateway); "
"rebinding with SO_REUSEADDR", log_tag, host, port)
site = web.TCPSite(runner, host, port, reuse_address=True)
await site.start()
return site