Skip to content

The agent that grows with you

1.6 KB
Raw Blame
"""Active-session lease releases off the gateway event loop.

``ActiveSessionLease.release()`` takes the registry's file lock, re-reads and prunes the JSON (a
liveness probe per entry) and atomically rewrites it. Every turn end ran it on the loop, a measured
recurring stall with many turns finishing. Only that file write is deferred: the lease leaves this
process's view of the registry before ``release_soon`` returns (``mark_release_queued``), so the
next claim on the loop -- another session at ``max_concurrent_sessions``, or a Desktop/TUI writer
taking over this session -- sees the slot free, exactly as when the release ran inline. Releases
go to ONE worker so the durable drops land in turn-end order. The lease pinned its registry path
at acquisition, so the worker needs no profile scope.
"""

from __future__ import annotations

import concurrent.futures
import logging
import threading

logger = logging.getLogger(__name__)

_pool: concurrent.futures.ThreadPoolExecutor | None = None
_pool_lock = threading.Lock()


def release_soon(lease) -> None:
    """Retire *lease* from this process's registry view now and queue its durable release."""
    global _pool
    from hermes_cli.active_sessions import mark_release_queued

    mark_release_queued(lease)
    with _pool_lock:
        if _pool is None:
            _pool = concurrent.futures.ThreadPoolExecutor(max_workers=1, thread_name_prefix="active-lease-io")
        pool = _pool
    pool.submit(_release, lease)


def _release(lease) -> None:
    try:
        lease.release()
    except Exception:
        logger.debug("Failed to release active session slot", exc_info=True)