The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""start_gateway runs the unclean-exit state.db scan off the event loop, after the runner is live."""
import threading
from unittest.mock import AsyncMock
import pytest
from gateway import run_bootstrap
def test_scan_runs_on_a_daemon_thread_with_the_1800s_deadline(monkeypatch):
from gateway import lifecycle_ledger as ledger
seen, release, done = {}, threading.Event(), threading.Event()
def scan(evidence, *, deadline_s):
seen.update(evidence=evidence, deadline_s=deadline_s, thread=threading.current_thread())
release.wait(5) # still running when the caller returns: nothing waits on it
done.set()
monkeypatch.setattr(ledger, "run_deferred_integrity_check", scan)
evidence = {"prior_pid": 1234}
run_bootstrap._start_deferred_state_db_integrity_check(evidence)
assert not done.is_set()
release.set()
assert done.wait(5)
assert seen["evidence"] is evidence and seen["deadline_s"] == 1800.0
assert seen["thread"].daemon and seen["thread"].name == "state-db-integrity-check"
@pytest.fixture
def _startup(monkeypatch, tmp_path):
"""Drive the real ``start_gateway`` with a fake runner; record the order of startup milestones."""
from agent import memory_provider
from gateway import lifecycle_ledger as ledger
from gateway import run_api, run_runtime
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
events, release, scan_entered = [], threading.Event(), threading.Event()
state = {"evidence": None}
class _LiveRunner:
def __init__(self, config):
from gateway.session import SessionStore
from hermes_constants import get_hermes_home
from hermes_state import SessionDB
self.session_store = SessionStore(get_hermes_home() / "sessions", config)
self._session_db = SessionDB(get_hermes_home() / "state.db")
self.session_store._db = self._session_db
self._draining = False
self._running = False
self._closed = False
self.config = config
self.should_exit_cleanly = False
self.exit_reason = None
self.exit_code = None
self.adapters = {}
async def start(self):
events.append("runner_started")
self._running = True
return True
def _start_systemd_watchdog(self):
pass
async def stop(self):
self._running = False
if not self._closed:
self._closed = True
self.session_store.close_all_db_handles()
self._session_db.close()
real_spawn = memory_provider.spawn_context_thread
def spawn(target, *, name, **kwargs):
if name == "state-db-integrity-check":
events.append("scan_launched")
return real_spawn(target, name=name, **kwargs)
def scan(evidence, *, deadline_s):
state["scanned"] = evidence
scan_entered.set()
release.wait(10)
async def wait_runtime(runner):
events.append(("runtime_waited", release.is_set()))
monkeypatch.setattr("gateway.run._host_attach_or_none", AsyncMock(return_value=None))
monkeypatch.setattr("gateway.status.get_running_pid", lambda: None)
monkeypatch.setattr("tools.skills_sync.sync_skills", lambda quiet=True: None)
monkeypatch.setattr("hermes_logging.setup_logging", lambda hermes_home, mode: tmp_path)
monkeypatch.setattr("hermes_logging._add_rotating_handler", lambda *args, **kwargs: None)
monkeypatch.setattr("gateway.run.GatewayRunner", _LiveRunner)
monkeypatch.setattr(ledger, "record_startup", lambda: state["evidence"])
monkeypatch.setattr(ledger, "run_deferred_integrity_check", scan)
monkeypatch.setattr(memory_provider, "spawn_context_thread", spawn)
monkeypatch.setattr(run_bootstrap, "_start_gateway_start_cron_and_housekeeping",
lambda runner: (threading.Event(), None, None, None))
monkeypatch.setattr(run_bootstrap, "_start_gateway_shutdown_tail", AsyncMock(return_value=True))
monkeypatch.setattr(run_runtime, "publish_gateway_runtime_ready", lambda runner: events.append("ready"))
monkeypatch.setattr(run_runtime, "wait_gateway_runtime", wait_runtime)
monkeypatch.setattr(run_api, "warm_gateway_dashboard", lambda runner: None)
yield events, state, scan_entered
release.set()
from gateway import host_rendezvous as hr
hr.release_host_lock(hr.ROLE_GATEWAY)
hr.clear_record(hr.ROLE_GATEWAY)
@pytest.mark.asyncio
async def test_unclean_exit_scan_starts_after_the_runner_and_does_not_hold_startup(_startup):
from gateway.config import GatewayConfig
events, state, scan_entered = _startup
state["evidence"] = evidence = {"prior_pid": 1234}
assert await run_bootstrap.start_gateway(config=GatewayConfig(), replace=False, verbosity=None) is True
# The scan is still blocked: startup reached READY and the runtime wait without it.
assert events == ["runner_started", "scan_launched", "ready", ("runtime_waited", False)]
assert scan_entered.wait(5) and state["scanned"] is evidence
@pytest.mark.asyncio
async def test_clean_previous_exit_launches_no_scan(_startup):
from gateway.config import GatewayConfig
events, _, scan_entered = _startup
assert await run_bootstrap.start_gateway(config=GatewayConfig(), replace=False, verbosity=None) is True
assert events == ["runner_started", "ready", ("runtime_waited", False)]
assert not scan_entered.is_set()