mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-07-28 18:19:28 +00:00
d3520944c7
`OpenVikingMemoryProvider.shutdown()` joins in-flight writers, deferred-commit
threads, and prefetch threads, but not `_runtime_start_thread` — the tracked
`daemon=True` waiter that runs `_finish_runtime_openviking_start`, which blocks
on network health probes (`_wait_for_openviking_health` polling + a
`_VikingClient.health()` request).
If the local OpenViking runtime is slow or unreachable, that waiter can still
be blocked in network I/O at interpreter exit. CPython then forcibly kills it
during `Py_FinalizeEx` (`PyThread_exit_thread` -> `__pthread_unwind` ->
`abort()`), producing SIGABRT (exit 134) with no traceback — the same daemon-
thread-at-exit failure class fixed for the Honcho provider.
Fix:
- `shutdown()` now joins `_runtime_start_thread` (timeout-bounded) alongside the
other tracked threads.
- `_wait_for_openviking_health()` gains a `should_stop` callback; the waiter
passes `lambda: self._shutting_down` so the poll loop bails out promptly once
`shutdown()` flips the flag, instead of lingering up to the 60s autostart
timeout and timing out the join (which would leave the thread alive).
- Add tests/plugins/memory/test_openviking_shutdown.py covering the short-circuit
and the shutdown-joins-runtime-thread behaviour.
(cherry picked from commit 5471ec7021)
70 lines
2.3 KiB
Python
70 lines
2.3 KiB
Python
"""Tests for OpenViking memory-provider shutdown teardown.
|
|
|
|
The runtime-autostart waiter is a tracked ``daemon=True`` thread that blocks
|
|
on network health probes. If ``shutdown()`` doesn't join it (and the waiter
|
|
doesn't bail on the shutdown flag), it can be left alive at interpreter exit,
|
|
which crashes CPython with SIGABRT at ``Py_FinalizeEx``. These tests assert
|
|
the waiter short-circuits on shutdown and that ``shutdown()`` waits for the
|
|
runtime-start thread.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
import time
|
|
from unittest.mock import patch
|
|
|
|
import plugins.memory.openviking as openviking_module
|
|
from plugins.memory.openviking import OpenVikingMemoryProvider
|
|
|
|
|
|
def test_wait_for_health_short_circuits_on_should_stop():
|
|
"""The health waiter returns False without probing when should_stop is set,
|
|
so the daemon thread running it can be join()ed promptly at shutdown."""
|
|
probes: list[str] = []
|
|
|
|
def _reach(endpoint):
|
|
probes.append(endpoint)
|
|
return (False, "down")
|
|
|
|
with patch.object(
|
|
openviking_module, "_validate_openviking_reachability", _reach
|
|
):
|
|
result = openviking_module._wait_for_openviking_health(
|
|
"http://example.invalid",
|
|
timeout_seconds=60.0,
|
|
should_stop=lambda: True,
|
|
)
|
|
|
|
assert result is False
|
|
assert probes == [] # bailed before the first network probe
|
|
|
|
|
|
def test_shutdown_waits_for_runtime_start_thread():
|
|
"""shutdown() must join the runtime-autostart waiter thread.
|
|
|
|
The fake waiter does post-stop work (a short sleep) once it observes the
|
|
shutdown flag. If shutdown() joins it, that work has completed by the time
|
|
shutdown() returns; without the join, shutdown() returns early and the
|
|
thread is still running (the SIGABRT-at-exit failure mode).
|
|
"""
|
|
provider = OpenVikingMemoryProvider()
|
|
started = threading.Event()
|
|
finished = threading.Event()
|
|
|
|
def _runtime():
|
|
started.set()
|
|
while not provider._shutting_down:
|
|
time.sleep(0.01)
|
|
time.sleep(0.2) # work that must finish during shutdown's join
|
|
finished.set()
|
|
|
|
t = threading.Thread(target=_runtime, daemon=True, name="openviking-runtime-start")
|
|
provider._runtime_start_thread = t
|
|
t.start()
|
|
assert started.wait(2.0)
|
|
|
|
provider.shutdown()
|
|
|
|
assert finished.is_set()
|
|
assert not t.is_alive()
|