mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 19:36:54 +00:00
Prepare dependency generations before selecting them. Keep shipped tool bytes separate from writable additions, and store facts beside their entries. Validate proposed plugin sets before config publication. Restore the previous config if the facts write fails. Consolidate duplicate updater, backup, setup, and voice helpers. Repair launcher selection, dependency consumers, download ownership, update feeds, and native Windows process and file handling. Verification: 206 changed/prior-failing Python files reported 4630 passed, one failed, and 330 skipped. Fix the remaining Hindsight fixture boundary. The final targeted rerun reported 234 passed and two skipped. The store review regression batch reported 83 passed and one skipped. Desktop TypeScript checks, 56 selected Electron tests, 24 release tests, and the removed-import/compatibility guards passed. This is an integration checkpoint, not full audit acceptance. The complete Python suite has not run on this fixed tree. Crash-atomic plugin publication, generation cleanup, receipt correlation, and packaged lifecycle acceptance remain open in docs/pm-audit-status.md.
165 lines
6.2 KiB
Python
165 lines
6.2 KiB
Python
"""Regression: the timeout watchdog must not release the client's FDs.
|
|
|
|
Salvaged from PR #72260 (@necoweb3 / dsad), adapted to the re-armable
|
|
no-progress watchdog introduced in PR #99660.
|
|
|
|
``close()`` from a thread that does not own the in-flight httpx connection
|
|
releases the raw TLS fd while the owner's OpenSSL BIO still caches that
|
|
integer. The kernel can hand the same integer to the next ``open()`` in the
|
|
process — a SessionDB or kanban.db handle — and the owner's unwinding TLS
|
|
flush then writes an application-data record into that database file
|
|
(#29507 / #67142 / #70773). ``shutdown()`` is FD-safe from any thread;
|
|
``close()`` is not, so it belongs to the owning thread.
|
|
"""
|
|
|
|
import threading
|
|
import time
|
|
from types import SimpleNamespace
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from agent.auxiliary_client import _CodexCompletionsAdapter
|
|
|
|
|
|
def _adapter_with_recording_client(stream):
|
|
"""Build an adapter whose client records (action, thread) events.
|
|
|
|
The nested ``_client._transport._pool._connections`` shape is what
|
|
``force_close_tcp_sockets`` traverses.
|
|
"""
|
|
events = []
|
|
|
|
class _Sock:
|
|
def shutdown(self, how):
|
|
events.append(("shutdown", threading.get_ident()))
|
|
|
|
def close(self):
|
|
events.append(("sock.close", threading.get_ident()))
|
|
|
|
sock = _Sock()
|
|
|
|
class _Conn:
|
|
def __init__(self):
|
|
self._connection = self
|
|
self._network_stream = self
|
|
|
|
def get_extra_info(self, name):
|
|
return sock if name == "socket" else None
|
|
|
|
class _Client:
|
|
def __init__(self):
|
|
self._transport = SimpleNamespace(
|
|
_pool=SimpleNamespace(_connections=[_Conn()])
|
|
)
|
|
|
|
class _LeafClient:
|
|
def __init__(self):
|
|
self._client = _Client()
|
|
self.base_url = "https://chatgpt.com/backend-api/codex"
|
|
self.responses = SimpleNamespace(create=lambda **kw: stream)
|
|
|
|
def close(self):
|
|
events.append(("client.close", threading.get_ident()))
|
|
|
|
return _CodexCompletionsAdapter(_LeafClient(), "gpt-5.5"), events
|
|
|
|
|
|
class TestCodexAuxiliaryTimeoutFdOwnership:
|
|
def test_stalled_stream_timeout_shuts_down_from_timer_and_closes_from_owner(self):
|
|
"""The watchdog Timer fires on a stalled stream: it may only
|
|
shutdown(); the real close() must land on the owning thread in the
|
|
adapter's ``finally``."""
|
|
|
|
interrupted = threading.Event()
|
|
def _stalled():
|
|
assert interrupted.wait(10), "watchdog did not interrupt the stalled transport"
|
|
yield SimpleNamespace(type="response.in_progress")
|
|
|
|
adapter, events = _adapter_with_recording_client(_stalled())
|
|
socket = adapter._client._client._transport._pool._connections[0].get_extra_info("socket")
|
|
original_shutdown = socket.shutdown
|
|
def shutdown(how):
|
|
original_shutdown(how)
|
|
interrupted.set()
|
|
socket.shutdown = shutdown
|
|
owner_tid = threading.get_ident()
|
|
|
|
def _consume(stream, *, model, on_event):
|
|
del model
|
|
for event in stream:
|
|
on_event(event)
|
|
return SimpleNamespace(output=[], usage=None)
|
|
|
|
with (
|
|
patch("agent.auxiliary_client._AUX_STREAM_NO_PROGRESS_TIMEOUT_SECONDS", 0.3),
|
|
patch("agent.auxiliary_client._evict_cached_client_instance"),
|
|
patch("agent.codex_runtime._consume_codex_event_stream", _consume),
|
|
pytest.raises(TimeoutError),
|
|
):
|
|
adapter.create(
|
|
messages=[{"role": "user", "content": "summarize"}],
|
|
timeout=300,
|
|
)
|
|
|
|
# Give the daemon Timer thread a beat to finish its callback.
|
|
time.sleep(0.2)
|
|
actions = [a for a, _ in events]
|
|
# Stranger thread (Timer) only shut the sockets down.
|
|
shutdown_tids = {tid for a, tid in events if a == "shutdown"}
|
|
assert "shutdown" in actions, events
|
|
assert owner_tid not in shutdown_tids, "shutdown ran on owner thread"
|
|
# close() from a stranger thread is the corruption vector — banned.
|
|
stranger_closes = [
|
|
(a, tid) for a, tid in events
|
|
if a in {"client.close", "sock.close"} and tid != owner_tid
|
|
]
|
|
assert not stranger_closes, f"stranger-thread FD release: {stranger_closes}"
|
|
# The owning thread released the FDs on unwind.
|
|
assert ("client.close", owner_tid) in events, events
|
|
|
|
def test_owner_thread_deadline_hit_closes_directly(self):
|
|
"""When the OWNING thread detects the deadline in _check_cancelled,
|
|
it may close() directly — no shutdown-only detour required."""
|
|
|
|
def _one_keepalive_then_block():
|
|
yield SimpleNamespace(type="response.in_progress")
|
|
time.sleep(1.0) # past the patched window; owner detects on next event
|
|
yield SimpleNamespace(type="response.in_progress")
|
|
|
|
adapter, events = _adapter_with_recording_client(_one_keepalive_then_block())
|
|
owner_tid = threading.get_ident()
|
|
|
|
def _consume(stream, *, model, on_event):
|
|
del model
|
|
for event in stream:
|
|
on_event(event)
|
|
return SimpleNamespace(output=[], usage=None)
|
|
|
|
# Cancel the watchdog race by making the Timer window huge relative
|
|
# to the owner's per-event check: patch the timer to never fire.
|
|
class _NeverTimer:
|
|
def __init__(self, *_a, **_k):
|
|
self.daemon = True
|
|
|
|
def start(self):
|
|
pass
|
|
|
|
def cancel(self):
|
|
pass
|
|
|
|
with (
|
|
patch("agent.auxiliary_client._AUX_STREAM_NO_PROGRESS_TIMEOUT_SECONDS", 0.3),
|
|
patch("agent.auxiliary_client._evict_cached_client_instance"),
|
|
patch("agent.auxiliary_client.threading.Timer", _NeverTimer),
|
|
patch("agent.codex_runtime._consume_codex_event_stream", _consume),
|
|
pytest.raises(TimeoutError),
|
|
):
|
|
adapter.create(
|
|
messages=[{"role": "user", "content": "summarize"}],
|
|
timeout=300,
|
|
)
|
|
|
|
stranger = [(a, t) for a, t in events if t != owner_tid]
|
|
assert not stranger, f"non-owner activity: {stranger}"
|
|
assert ("client.close", owner_tid) in events, events
|