Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
fix(websocket): stop treating SO_ACCEPTCONN as portable in listener health check
Krislu1221bd9b74e2c772
diff --git a/nanobot/channels/websocket/runtime.py b/nanobot/channels/websocket/runtime.pyindex 92f5f12fe..7e54209ef 100644--- a/nanobot/channels/websocket/runtime.py+++ b/nanobot/channels/websocket/runtime.py@@ -3,6 +3,7 @@from __future__ import annotationsimport asyncio+import errnoimport ipaddressimport jsonimport socket@@ -538,14 +539,32 @@ class WebSocketChannel(BaseChannel):# -- Server lifecycle and connection ingress ---------------------------@staticmethod- def _listener_is_serving(server: Server) -> bool:+ def _socket_is_accepting(sock: socket.socket) -> bool:+ """Return whether a bound socket still advertises a listen capability.++ ``SO_ACCEPTCONN`` is not portable: macOS/BSD raise ``OSError`` with+ ``ENOPROTOOPT`` ("Protocol not available") for this option even on a+ perfectly healthy listening socket. Treating that as "not serving"+ makes the listener look permanently degraded, so the caller retries+ forever and the channel never reaches a ready state. When the option+ is unavailable we fall back to the file-descriptor liveness check.+ """+ if sock.fileno() < 0:+ return False+ try:+ return bool(sock.getsockopt(socket.SOL_SOCKET, socket.SO_ACCEPTCONN))+ except OSError as exc:+ if exc.errno in (errno.ENOPROTOOPT, errno.EOPNOTSUPP, errno.EINVAL):+ return True+ raise++ @classmethod+ def _listener_is_serving(cls, server: Server) -> bool:"""Return whether every bound socket still has a live listen capability."""try:sockets = server.socketsreturn bool(sockets) and server.is_serving() and all(- sock.fileno() >= 0- and bool(sock.getsockopt(socket.SOL_SOCKET, socket.SO_ACCEPTCONN))- for sock in sockets+ cls._socket_is_accepting(sock) for sock in sockets)except OSError:return Falsediff --git a/tests/channels/test_websocket_listener_health.py b/tests/channels/test_websocket_listener_health.pynew file mode 100644index 000000000..22b85e9c7--- /dev/null+++ b/tests/channels/test_websocket_listener_health.py@@ -0,0 +1,86 @@+"""Regression tests for WebSocket listener health probing portability."""++from __future__ import annotations++import errno+import socket+from typing import Any++import pytest++from nanobot.channels.websocket.runtime import WebSocketChannel+++class _StubSocket:+ """Minimal socket stand-in: real sockets forbid attribute patching."""++ def __init__(self, *, fileno: int, error: OSError | None = None, value: int = 1):+ self._fileno = fileno+ self._error = error+ self._value = value++ def fileno(self) -> int:+ return self._fileno++ def getsockopt(self, *_args: Any, **_kwargs: Any) -> int:+ if self._error is not None:+ raise self._error+ return self._value+++def listening_socket() -> socket.socket:+ sock = socket.socket()+ sock.bind(("127.0.0.1", 0))+ sock.listen(1)+ yield sock+ sock.close()+++def test_real_listening_socket_is_accepting(listening_socket: socket.socket) -> None:+ """A genuinely listening socket must never be reported as degraded.++ On macOS/BSD this exercises the ``ENOPROTOOPT`` fallback path; on Linux it+ exercises the native ``SO_ACCEPTCONN`` path. Both must agree.+ """+ assert WebSocketChannel._socket_is_accepting(listening_socket) is True+++def test_closed_socket_is_not_accepting() -> None:+ sock = socket.socket()+ sock.bind(("127.0.0.1", 0))+ sock.listen(1)+ sock.close()++ assert WebSocketChannel._socket_is_accepting(sock) is False+++ "unsupported_errno",+ [errno.ENOPROTOOPT, errno.EOPNOTSUPP, errno.EINVAL],+)+def test_unsupported_sockopt_falls_back_to_fd_liveness(unsupported_errno: int) -> None:+ """macOS/BSD reject ``SO_ACCEPTCONN`` even on healthy listeners.++ Treating that rejection as "not serving" made the listener look permanently+ degraded, so the channel retried forever and never became ready.+ """+ sock = _StubSocket(fileno=3, error=OSError(unsupported_errno, "Protocol not available"))++ assert WebSocketChannel._socket_is_accepting(sock) is True+++def test_unexpected_oserror_propagates() -> None:+ sock = _StubSocket(fileno=3, error=OSError(errno.EBADF, "Bad file descriptor"))++ with pytest.raises(OSError) as excinfo:+ WebSocketChannel._socket_is_accepting(sock)++ assert excinfo.value.errno == errno.EBADF+++def test_unsupported_sockopt_still_rejects_dead_fd() -> None:+ """The portability fallback must not mask an already-closed listener."""+ sock = _StubSocket(fileno=-1, error=OSError(errno.ENOPROTOOPT, "Protocol not available"))++ assert WebSocketChannel._socket_is_accepting(sock) is False