Skip to content
Python

fix(server): avoid deadlock when shutting down on signals (#89)

u7-u7638d1b7bde42
diff --git a/hy_memory/server.py b/hy_memory/server.py
index cb94c3c..4d51487 100644
--- a/hy_memory/server.py
+++ b/hy_memory/server.py
@@ -29,7 +29,7 @@ import logging
import os
import re
import signal
-import sys
+import threading
from datetime import datetime
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Any, Dict, Optional
@@ -495,6 +495,16 @@ class MemoryHTTPHandler(BaseHTTPRequestHandler):
_json_response(self, 200, result)
+def _request_shutdown(server: ThreadingHTTPServer) -> None:
+ """Ask ``serve_forever`` to stop without blocking the calling thread.
+
+ ``BaseServer.shutdown()`` waits for the ``serve_forever`` loop to exit. A
+ signal handler runs on the very thread executing that loop, so calling it
+ there deadlocks forever. Hand the call to a helper thread instead.
+ """
+ threading.Thread(target=server.shutdown, daemon=True).start()
+
+
def run_server(port: int = 19527, host: str = "127.0.0.1"):
"""Start the HTTP server (blocking)."""
# Configure logging — basicConfig for root; hy_memory level set after client init
@@ -523,13 +533,12 @@ def run_server(port: int = 19527, host: str = "127.0.0.1"):
logger.info(f"[server] Listening on http://{host}:{port}")
logger.info(f"[server] Health check: http://{host}:{port}/healthz")
- # Graceful shutdown
+ # Graceful shutdown. The signal handler only asks a helper thread to stop
+ # the loop; cleanup runs after serve_forever() returns so it cannot race
+ # the request threads or deadlock the serving thread.
def _shutdown(signum, frame):
logger.info("[server] Shutting down...")
- server.shutdown()
- if _client is not None:
- _client.close()
- sys.exit(0)
+ _request_shutdown(server)
signal.signal(signal.SIGINT, _shutdown)
signal.signal(signal.SIGTERM, _shutdown)
@@ -538,6 +547,10 @@ def run_server(port: int = 19527, host: str = "127.0.0.1"):
server.serve_forever()
except KeyboardInterrupt:
_shutdown(None, None)
+ finally:
+ server.server_close()
+ if _client is not None:
+ _client.close()
def main():
diff --git a/tests/test_server_shutdown.py b/tests/test_server_shutdown.py
new file mode 100644
index 0000000..905c05a
--- /dev/null
+++ b/tests/test_server_shutdown.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+"""HTTP server signal shutdown must not deadlock the serving thread."""
+
+import subprocess
+import sys
+import textwrap
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from hy_memory.server import _request_shutdown
+
+
+class _Handler(BaseHTTPRequestHandler):
+ def do_GET(self): # pragma: no cover - the test only needs a live server
+ self.send_response(200)
+ self.end_headers()
+
+ def log_message(self, *args): # pragma: no cover - silence test output
+ pass
+
+
+def test_request_shutdown_returns_promptly():
+ server = ThreadingHTTPServer(("127.0.0.1", 0), _Handler)
+ server.daemon_threads = True
+ thread = threading.Thread(target=server.serve_forever)
+ thread.start()
+ try:
+ started = time.monotonic()
+ _request_shutdown(server)
+ assert time.monotonic() - started < 1.0
+ thread.join(timeout=2.0)
+ assert not thread.is_alive()
+ finally:
+ server.server_close()
+
+
+def test_signal_handler_does_not_deadlock_the_serving_thread():
+ """A signal handler calling shutdown() directly hangs forever.
+
+ Run the serving loop on the main thread (as run_server does), fire an
+ alarm, and require the process to exit on its own.
+ """
+ script = textwrap.dedent(
+ """
+ import signal
+ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+ from hy_memory.server import _request_shutdown
+
+ class H(BaseHTTPRequestHandler):
+ def do_GET(self):
+ self.send_response(200)
+ self.end_headers()
+ def log_message(self, *args):
+ pass
+
+ server = ThreadingHTTPServer(("127.0.0.1", 0), H)
+
+ def _handler(signum, frame):
+ _request_shutdown(server)
+
+ signal.signal(signal.SIGALRM, _handler)
+ signal.alarm(1)
+ server.serve_forever()
+ server.server_close()
+ print("exited")
+ """
+ )
+ result = subprocess.run(
+ [sys.executable, "-c", script],
+ capture_output=True,
+ text=True,
+ timeout=10,
+ )
+ assert result.returncode == 0, result.stderr
+ assert "exited" in result.stdout