| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115 |
- """The live session feeds (``session.list`` live scope, ``session.active_list``) read off the loop.
- Both feeds cover every session in ``authority.sessions``, which can hold thousands of rows (mostly
- finished cron runs; boot restores only open sessions, an ended one comes back on first touch).
- Walking it one row at a time on the loop cost three full hydrations plus a receipt JSON parse per
- session: the loop stalled past 10 s, WS writes and the Telegram adapter's ``updater.stop()`` missed
- their deadlines (#141236).
- Here the loop does only in-memory work (authorization and liveness from ``LiveSession``); the store
- facts for a batch of sessions are ONE worker-thread read: picker columns, runtime revision and
- generation, pending admissions, and the local receipt target's ``ended_at``.
- """
- from __future__ import annotations
- import asyncio
- import json
- from dataclasses import dataclass
- from gateway.session_contract import SessionHandle, SessionRef
- from hermes_state_runtime import RuntimeStoreError
- # Sessions per worker-thread read; each batch is one await, so the loop serves other work between them.
- LISTING_BATCH = 256
- _SKIPPED_REASONS = frozenset({'permission_denied', 'profile_mismatch', 'not_found'})
- @dataclass(frozen=True)
- class LiveEntry:
- session_id: str
- live: object
- handle: SessionHandle
- row: dict
- pending: list
- closed: bool
- def _store_facts(db, session_ids):
- """Worker thread: ``{sid: row}`` and ``{sid: [pending admission]}`` for *session_ids*, in two reads.
- ``target_ended_at`` is the local receipt target's ``ended_at`` (``closed_and_unviewed``'s read):
- SQLite extracts the target from the receipt, so no receipt is parsed in Python. A malformed or
- non-local receipt reads as no target, as ``_local_target`` does."""
- from hermes_state_local import POLICY_PREFIX
- ids = json.dumps(list(session_ids))
- with db._read_ctx() as conn:
- rows = conn.execute(
- "SELECT s.id, s.source, s.title, s.started_at, s.ended_at, s.message_count, s.model, s.hidden, "
- "s.archived, s.runtime_revision, s.runtime_generation, "
- "(SELECT t.ended_at FROM state_meta m JOIN sessions t ON t.id = CASE WHEN json_valid(m.value) "
- "THEN json_extract(m.value, '$.entry.session_id') END WHERE m.key = ? || s.id) AS target_ended_at "
- "FROM sessions s WHERE s.id IN (SELECT value FROM json_each(?))", (POLICY_PREFIX, ids)).fetchall()
- pending = conn.execute(
- "SELECT target_session_id, admission_id, seq, status FROM session_admissions "
- "WHERE target_session_id IN (SELECT value FROM json_each(?)) "
- "AND status IN ('queued','started','unknown') ORDER BY seq", (ids,)).fetchall()
- by_session: dict[str, list] = {}
- for row in pending:
- by_session.setdefault(row['target_session_id'], []).append(dict(row))
- return {row['id']: dict(row) for row in rows}, by_session
- def _masked_pending(live, rows):
- """``SessionAuthority._pending_rows``: a settlement not yet published still reads as its started claim."""
- if not live.settling:
- return rows
- merged = {row['admission_id']: row for row in rows}
- merged.update(live.settling)
- return sorted(merged.values(), key=lambda row: row['seq'])
- def _execution_state(pending) -> str:
- statuses = {row['status'] for row in pending}
- return 'unknown' if 'unknown' in statuses else ('running' if 'started' in statuses else 'idle')
- def _readable(authority, actor, session_id) -> bool:
- if session_id not in authority.sessions:
- return False # retired since the snapshot: a listing never restores a session
- from gateway.session_retirement import LISTING_READ
- token = LISTING_READ.set(True)
- try:
- authority.authorize(actor, SessionRef(actor.profile_id, session_id), 'session:read')
- except RuntimeStoreError as exc:
- if exc.reason not in _SKIPPED_REASONS:
- raise
- return False
- finally:
- LISTING_READ.reset(token)
- return True
- async def live_entries(authority, actor) -> list[LiveEntry]:
- """Every live session *actor* may read, with its handle, picker row and closed-and-unviewed verdict."""
- from gateway.session_local_close import closed_idle_unviewed
- entries = []
- snapshot = tuple(authority.sessions)
- for start in range(0, len(snapshot), LISTING_BATCH):
- batch = [sid for sid in snapshot[start:start + LISTING_BATCH] if _readable(authority, actor, sid)]
- if not batch:
- continue
- rows, pending = await asyncio.to_thread(_store_facts, authority.db, batch)
- if authority.retiring or authority.retired:
- return [] # parked or unserved during the read: nothing here is this profile's to list any more
- for sid in batch:
- live, row = authority.sessions.get(sid), rows.get(sid)
- if live is None or row is None:
- continue # retired during the read, or its row was deleted (``_handle``'s not_found)
- masked = _masked_pending(live, pending.get(sid, []))
- state = _execution_state(masked)
- handle = SessionHandle(SessionRef(authority.profile_id, sid), authority.instance_id, authority.epoch,
- row['runtime_revision'], row['runtime_generation'], state)
- entries.append(LiveEntry(sid, live, handle, row, masked,
- closed_idle_unviewed(live, state, row['target_ended_at'])))
- return entries
|