| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206 |
- """Authority-local async serialization; file locks cover only short synchronous mailbox I/O."""
- import asyncio
- from contextlib import asynccontextmanager
- from tools.bot_live_delivery import _locked, _read, _write
- @asynccontextmanager
- async def mailbox_lock(authority):
- lock = getattr(authority, '_bot_mailbox_lock', None)
- if lock is None:
- lock = authority._bot_mailbox_lock = asyncio.Lock()
- async with lock:
- active = getattr(authority, '_bot_mailbox_operations', None)
- if active is None:
- active = authority._bot_mailbox_operations = set()
- task = asyncio.current_task()
- active.add(task)
- try:
- yield
- finally:
- active.discard(task)
- from gateway.session_runtime_workers import persist_work_count
- persist_work_count(authority)
- async def _mailbox_io(operation, *args):
- """Keep the caller's mailbox ownership until its physical I/O ends, even after cancellation."""
- pending = asyncio.create_task(asyncio.to_thread(operation, *args))
- cancelled = None
- while True:
- try:
- result = await asyncio.shield(pending)
- except asyncio.CancelledError as exc:
- if pending.cancelled():
- raise
- cancelled = exc
- except Exception:
- if cancelled is not None:
- raise cancelled
- raise
- else:
- if cancelled is not None:
- raise cancelled
- return result
- def _read_receipt(home, key):
- with _locked(home) as root:
- return root, _read(root / f'{key}.json')
- async def read_receipt(home, key):
- return await _mailbox_io(_read_receipt, home, key)
- _UNCHECKED = object()
- def _write_receipt(home, record, expect=_UNCHECKED):
- with _locked(home) as root:
- path = root / f"{record['delivery_id']}.json"
- current = _read(path)
- if expect is not _UNCHECKED and (current or {}).get('status') != expect:
- return False
- if current is not None and current.get('principal_id'):
- from hermes_state_runtime import RuntimeStoreError
- fields = ('profile_home', 'session_id', 'principal_id', 'message', 'author')
- if (any(current.get(key) != record.get(key) for key in fields)
- or current.get('notification_category', 'result') != record.get('notification_category', 'result')
- or (current.get('admission_id') and current['admission_id'] != record.get('admission_id'))):
- raise RuntimeStoreError('admission_conflict')
- merged = {**(current or {}), **record}
- if merged != current:
- _write(path, merged)
- return True
- async def write_receipt(home, record, *, expect=_UNCHECKED):
- return await _mailbox_io(_write_receipt, home, record, expect)
- def _scan_receipts(home, pins=None):
- from gateway.session_bot import _scan_records
- with _locked(home) as root:
- return root, list(_scan_records(root, pins))
- def _withdraw_pin(home, key):
- with _locked(home) as root:
- path = root / f'{key}.json'
- current = _read(path)
- if current is not None and current.get('status') == 'ambiguous' and not current.get('admission_id'):
- path.unlink()
- return True
- return False
- async def withdraw_pin(home, key):
- """Drop a pre-admission pin the FIFO definitely refused (nothing committed), only while it is
- still that pin, so the same-id retry admits instead of answering ``unknown_execution``."""
- return await _mailbox_io(_withdraw_pin, home, key)
- # What ``_admit`` lays over a legacy ticket when it pins it (``legacy=``); the ticket never had them.
- _PIN_FIELDS = ('profile_home', 'session_id', 'principal_id', 'operator')
- def _requeue_pin(home, key):
- with _locked(home) as root:
- path = root / f'{key}.json'
- current = _read(path)
- if (current is None or current.get('status') != 'ambiguous' or current.get('admission_id')
- or 'owner' not in current):
- return None
- ticket = {k: v for k, v in current.items() if k not in _PIN_FIELDS}
- ticket['status'] = 'queued'
- _write(path, ticket)
- return ticket
- async def requeue_pin(home, key):
- """Restore the queued legacy ticket a pre-admission pin was laid over (nothing committed), only
- while it is still that pin: its id, message, sequence and created_at are kept, so ``_migrate``
- admits it once in its FIFO place. Returns the ticket, or None when the pin is gone or changed."""
- return await _mailbox_io(_requeue_pin, home, key)
- def _refuse_pin(home, key):
- from tools.bot_failure_reasons import AGENT_BLOCKED
- with _locked(home) as root:
- path = root / f'{key}.json'
- current = _read(path)
- if current is not None and current.get('status') == 'ambiguous' and not current.get('admission_id'):
- current.update(status='failed', refused=True, reply='', error='Bot Chat delivery was refused',
- reason=AGENT_BLOCKED)
- _write(path, current)
- async def refuse_pin(home, key):
- """Settle a pre-admission pin the FIFO definitely refused for good (nothing committed) as a
- terminal ``failed`` receipt, only while it is still that pin: never re-sent, nothing unknown."""
- return await _mailbox_io(_refuse_pin, home, key)
- async def scan_receipts(home, pins=None):
- """Bulk scan; an owner scan passes ``pins`` to collect pre-admission pins instead of warning."""
- return await _mailbox_io(_scan_receipts, home, pins)
- def remember_receipt(authority, home, record):
- index = getattr(authority, '_bot_receipt_index', None)
- if index is None:
- index = authority._bot_receipt_index = {}
- if record['status'] in {'settled', 'failed', 'cancelled'}:
- index.pop(record['delivery_id'], None)
- else:
- index[record['delivery_id']] = (home, record['session_id'])
- def track_receipt_task(authority, task):
- tasks = getattr(authority, '_bot_receipt_tasks', None)
- if tasks is None:
- tasks = authority._bot_receipt_tasks = set()
- tasks.add(task)
- def done(finished):
- tasks.discard(finished)
- if not finished.cancelled():
- error = finished.exception()
- if error is not None:
- import logging
- logging.getLogger(__name__).warning('Bot receipt projection failed: %s', type(error).__name__)
- task.add_done_callback(done)
- def wake_bot_receipts(authority, session_id):
- """Re-arm paused receipts from owner publication, without making external pollers dial RPC."""
- pending = getattr(authority, '_bot_receipt_refreshes', None)
- if pending is None:
- pending = authority._bot_receipt_refreshes = {}
- authority._bot_receipt_dirty = set()
- for key, (home, owner) in list(getattr(authority, '_bot_receipt_index', {}).items()):
- if owner != session_id:
- continue
- if key in pending and not pending[key].done():
- authority._bot_receipt_dirty.add(key)
- else:
- _start_refresh(authority, home, key)
- def _start_refresh(authority, home, key):
- from gateway.session_bot import refresh_receipt
- async def refresh_until_current():
- while True:
- authority._bot_receipt_dirty.discard(key)
- await refresh_receipt(authority, home, key)
- if key not in authority._bot_receipt_dirty or key not in authority._bot_receipt_index:
- return
- task = asyncio.create_task(refresh_until_current())
- authority._bot_receipt_refreshes[key] = task
- def done(finished):
- if authority._bot_receipt_refreshes.get(key) is finished:
- authority._bot_receipt_refreshes.pop(key, None)
- authority._bot_receipt_dirty.discard(key)
- task.add_done_callback(done)
- track_receipt_task(authority, task)
|