| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687 |
- """A local receipt's compression catch-up (#140060), committed off the owner loop.
- ``adopt_untracked_compression`` takes the writer lock, up to ``_WRITE_PATIENCE_S`` when contended. On
- the owner loop that stalls every profile it serves (streams, controls, admissions), including during
- a hot-profile activation. So the async paths that restore a receipt (boot and hot-profile recovery, a
- socket's first read) commit the catch-up in a worker first, and the restore that follows only reads.
- A restore reached synchronously on the loop hands it to a tracked worker (``schedule_adoption``).
- """
- import asyncio
- import logging
- from functools import partial
- from hermes_state_runtime import RuntimeStoreError
- logger = logging.getLogger(__name__)
- def on_owner_loop():
- try:
- asyncio.get_running_loop()
- except RuntimeError:
- return False
- return True
- def _due(authority, sid):
- """*sid*'s stored receipt when a catch-up would commit for it on this owner, else None. Read-only."""
- from gateway.session_local_recovery import owned_receipt
- from hermes_state_local_lineage import adoptable_compression
- try:
- receipt = owned_receipt(authority, sid)[0]
- with authority.db._read_ctx() as conn:
- return receipt if adoptable_compression(conn, receipt) is not None else None
- except (KeyError, TypeError, ValueError, AttributeError):
- return None # the restore refuses this receipt and logs the check that failed
- def _adopt(authority, sid, receipt):
- from hermes_state_local_lineage import adopt_untracked_compression
- adopt_untracked_compression(authority.db, epoch=authority.epoch, session_id=sid, expected=receipt)
- async def adopt_before_restore(authority, sid, *, tracked=True):
- """Commit *sid*'s due catch-up in a worker, so the restore that follows only reads.
- ``tracked=False``: an authority still being built, not yet published for retirement to join."""
- receipt = _due(authority, sid)
- if receipt is None:
- return
- write = partial(_adopt, authority, sid, receipt)
- try:
- if tracked:
- from gateway.session_runtime_workers import tracked_write
- await tracked_write(authority, write)
- else:
- await asyncio.to_thread(write)
- except RuntimeStoreError as exc: # the restore that follows refuses the receipt and logs it
- logger.warning('Local session %s compression catch-up failed: %s', sid, exc.reason)
- async def adopt_local_compressions(authority):
- """Boot and hot-profile recovery: every receipt's due catch-up, before ``recover_local_sessions``."""
- from gateway.session_local_recovery import local_receipt_ids
- for sid in local_receipt_ids(authority):
- await adopt_before_restore(authority, sid, tracked=False)
- def schedule_adoption(authority, sid, receipt):
- """A sync restore on the owner loop found *receipt*'s catch-up due: commit it in a tracked worker,
- then publish the session on the loop. One worker per session at a time."""
- from gateway.session_runtime_workers import track_mutation
- pending = getattr(authority, '_local_adoptions', None)
- if pending is None:
- pending = authority._local_adoptions = {}
- if sid in pending and not pending[sid].done():
- return
- logger.info('Local session %s: committing its compression catch-up off the owner loop', sid)
- async def adopt_then_publish():
- try:
- await asyncio.to_thread(_adopt, authority, sid, receipt)
- if not getattr(authority, 'retiring', False):
- from gateway.session_local_recovery import restore_local_session
- restore_local_session(authority, sid)
- except RuntimeStoreError as exc:
- logger.warning('Local session %s paused after its compression catch-up: %s', sid, exc.reason)
- pending[sid] = track_mutation(authority, adopt_then_publish())
|