mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
64 lines
3 KiB
Python
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
|