| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322 |
- """Receipt-only adapter ingress: the authority, not an HTTP/WS task, owns execution."""
- import asyncio
- from contextlib import asynccontextmanager
- from hermes_state_runtime import RuntimeStoreError
- @asynccontextmanager
- async def producer_scope(adapter, event):
- from gateway.run import _async_profile_runtime_scope
- from gateway.session_ingress_context import native_callback
- from gateway.session_authorities import authority_for_home
- runner = getattr(adapter._message_handler, '__self__', None)
- if getattr(runner, 'session_authority', None) is None:
- raise RuntimeStoreError('not_found')
- registered, profile = runner._owning_profile(adapter, adapter.platform)
- home = getattr(runner, '_native_transport_homes', {}).get(profile)
- if not registered or home is None:
- raise RuntimeStoreError('profile_mismatch')
- source = event.source
- # Identity is pinned through the runner's single canonicalization seam (a secondary's own
- # bot, or the primary's routed profile); a rejected primary route is refused downstream.
- if profile:
- runner._canonicalize(source, transport_profile=profile)
- runtime_home = runner._resolve_profile_home_for_source(source) if source.profile else home
- else:
- runtime_home = runner._admit_primary_source(source, home)
- if runtime_home is None:
- _refuse_parked(runner, getattr(source, '_rejected_route_profile', None))
- source.profile_route_rejected = True
- runtime_home = home
- source._authorization_profile_home = home
- # The routed profile's own ledger admits the delivery; an unserved route is refused. A park
- # can keep the profile's retiring authority (a turn outlived its Stop), which admits nothing.
- authority = authority_for_home(runner, runtime_home)
- if authority is None or getattr(authority, 'retiring', False):
- _refuse_parked(runner, getattr(source, 'profile', None) or profile)
- if authority is None:
- raise RuntimeStoreError('profile_mismatch')
- with native_callback(runner, event, home, profile):
- async with _async_profile_runtime_scope(runtime_home):
- yield authority
- def _refuse_parked(runner, profile):
- """A delivery routed to a parked profile is retryable, never refused for good: a rescan serves the
- profile again, so it is ``runtime_draining`` (a webhook answers 503; relay acknowledges and tells
- the sender, ``parked_route_refusal``), not the permanent ``profile_mismatch`` of a route to a
- profile this gateway does not serve."""
- from gateway.run_runtime import profile_parked
- if profile_parked(runner, profile):
- from gateway.parked_route_refusal import ParkedProfileRefusal
- raise ParkedProfileRefusal(profile)
- def parked_profile_refusal(runner, profile, route_config, admission_source):
- """A 503 for a webhook whose profile is not served right now, else None: a ``/p/<profile>/``
- prefix that is parked or has no serving authority here, or a coalesced route that
- ``profile_routes`` sends to a profile admission would refuse (a coalesced delivery is acknowledged
- before admission applies that route). A parked target is retryable (``Retry-After``); any other
- rejected target gets the answer the immediate route gives when admission refuses it.
- ``admission_source`` returns the ``SessionSource`` admission builds for this delivery
- (``WebhookAdapter._admission_source``), so ``profile_routes`` match here exactly as there. Answered
- before the delivery id is recorded: coalesced, ``deliver_only`` and ``cron_job`` routes act before
- (or without) an admission, so the in-memory id is their only replay guard, and a recorded id would
- answer the provider's retry as a duplicate once the profile is served again."""
- from aiohttp import web
- if _prefix_not_served(runner, profile):
- error = f'Profile {profile} is not being served; retry this delivery'
- else:
- refusal = _coalesced_route_refusal(runner, profile, route_config, admission_source)
- if refusal is None:
- return None
- if refusal == 'refused':
- # ``WebhookAdapter._dispatch_agent_run``'s answer when admission refuses the delivery.
- return web.json_response({'error': 'Admission unavailable; retry this delivery'}, status=503)
- error = 'The routed profile is not being served right now; retry this delivery'
- from gateway.parked_route_refusal import ParkedRouteRefused
- return web.json_response({'error': error}, status=ParkedRouteRefused.status, headers=ParkedRouteRefused.headers)
- def _prefix_not_served(runner, profile):
- """Parked, or on disk with no serving authority here (its own gateway still runs, or it is not
- picked up yet): the URL prefix resolves against the profiles on disk, the registry says what is
- served."""
- from gateway.run_runtime import profile_parked
- if profile_parked(runner, profile):
- return True
- if not profile or getattr(runner, 'session_authorities', None) is None:
- return False
- from gateway.session_authorities import authority_for_home
- from hermes_cli.profiles import get_profile_dir
- authority = authority_for_home(runner, get_profile_dir(profile))
- return authority is None or getattr(authority, 'retiring', False) is True
- def _coalesced_route_refusal(runner, profile, route_config, admission_source):
- """How admission would refuse a coalesced bare-route delivery that ``profile_routes`` sends away:
- ``'parked'`` (retryable), ``'refused'`` (a profile neither served here nor parked: standalone,
- unknown, or without a live authority), else None. Reads the profile the admission's own source
- resolved (``build_source`` asks ``GatewayRunner._profile_name_for_source`` on the same chat_id,
- user_id and names), so this edge and admission give one answer: an explicit ``/p/<profile>/``
- wins over ``profile_routes`` there, and routes apply only under multiplexing."""
- if profile or not isinstance(route_config.get('coalesce'), dict):
- return None
- from gateway.run_runtime import profile_parked
- source = admission_source()
- if getattr(source, 'profile_route_rejected', False):
- # A parked target leaves the served set, so the resolver rejects it; admission retries
- # that one (``_rejected_route_profile``) and refuses any other rejection for good.
- rejected = getattr(source, '_rejected_route_profile', None)
- return 'parked' if rejected and profile_parked(runner, rejected) else 'refused'
- routed = source.profile
- if not routed:
- return None
- if profile_parked(runner, routed):
- return 'parked'
- return 'refused' if _prefix_not_served(runner, routed) else None
- async def admit_producer(adapter, event):
- """Commit a producer delivery; ``None`` when a plugin skipped or consumed it.
- ``pre_gateway_dispatch`` and ``post_gateway_admission`` (#129958) fire once per admission, like
- ``GatewayInboundMixin._handle_message``: before the commit (a skipped or consumed delivery is
- never admitted, a rewrite is what gets committed; a consumer's reply rides
- ``event._consumer_reply`` for the caller's own reply leg), and never for a replay of an
- already-committed delivery (provider retry, relay re-send) nor at execution (PLG-5)."""
- async with producer_scope(adapter, event) as authority:
- from gateway.config import Platform
- from gateway.run_inbound_consumer import POST_ADMISSION_HOOK
- from hermes_cli.lifecycle import has_hook
- webhook = adapter.platform == Platform.WEBHOOK
- hooks = [name for name in ('pre_gateway_dispatch', POST_ADMISSION_HOOK) if has_hook(name)]
- if not (webhook or hooks):
- return await _admit_native(authority, event)
- from gateway.session_authority import native_write_started
- payload, principal = await _prepared(authority, event)
- writing = native_write_started.set(False)
- try:
- # An identical delivery (provider retry, relay re-send) overlapping this one waits here, then
- # rechecks the ledger: the retry check, the hooks and the commit run once per delivery.
- async with _delivery_turn((authority.profile_id, principal, event.message_id)):
- committed = payload, _committed(authority, principal, event.message_id)
- return await _admit_once(authority, event, webhook, hooks, committed)
- except (Exception, asyncio.CancelledError) as exc:
- # Refused after preparing (a command-shaped rewrite, a drain during the hooks, a conflict),
- # or cancelled (relay disconnect, shutdown) before the admission write began. A cancelled
- # write still commits (it is shielded): the bytes it commits are never released here.
- if not (isinstance(exc, asyncio.CancelledError) and native_write_started.get()):
- await asyncio.shield(_release_preparation(authority, payload))
- raise
- finally:
- native_write_started.reset(writing)
- async def _admit_once(authority, event, webhook, hooks, committed):
- from gateway.run_inbound_consumer import POST_ADMISSION_HOOK
- if webhook:
- prior = await _webhook_retry(authority, event, *committed)
- if prior is not None:
- return prior
- admitted = event
- if hooks and (webhook or not committed[1]):
- runner = authority.runner
- if 'pre_gateway_dispatch' in hooks:
- admitted = await runner._hm_pre_gateway_dispatch_hook(event, event.source)
- if admitted is None:
- await _release_preparation(authority, committed[0])
- return None
- if admitted is not event:
- # The rewrite is committed with the fingerprint of the delivery as received:
- # a provider retry or relay re-send resends that, and resolves to this row.
- from gateway.session_ingress_media import ingress_fingerprint
- admitted._ingress_sha256 = ingress_fingerprint(committed[0], event.raw_message)
- if POST_ADMISSION_HOOK in hooks:
- from gateway.run_inbound_consumer import run_post_admission_hook
- consumed, event._consumer_reply = await run_post_admission_hook(
- runner, admitted, admitted.source, runner._session_key_for_source(admitted.source))
- if consumed:
- await _release_preparation(authority, committed[0])
- return None
- return await _admit_native(authority, admitted)
- async def _admit_native(authority, event):
- # No adapter task brackets a producer's turn: the executor runs its adapter lifecycle (typing,
- # processing hooks) once the row starts executing (``session_producer_lifecycle``).
- event._producer_delivery = True
- return await authority.admit_native(event)
- # Producer deliveries in flight by (profile, principal, provider id) -> [lock, holder + waiters]. This
- # gateway is the only owner of producer ingress, so in-process coordination covers every request.
- _deliveries = {}
- @asynccontextmanager
- async def _delivery_turn(key):
- if not key[2]: # no provider id: admission mints one, nothing can overlap
- yield
- return
- from gateway.session_authority import keyed_turn
- async with keyed_turn(_deliveries, key):
- yield
- async def _release_preparation(authority, payload):
- """A delivery a plugin skipped or consumed, or one refused or cancelled after preparing, is never
- admitted: release the media its preparation (``_prepared``) copied into the retained store. A path
- another admission or an in-flight capture holds is kept, as for a refused admission."""
- from gateway.session_ingress_media import release_unheld_media
- if media := payload['native_text_v1'].get('media'):
- await asyncio.to_thread(release_unheld_media, authority.db, media, retain_history=False)
- async def _prepared(authority, event):
- """``(validated payload, principal)`` of this delivery. Preparing the payload runs the same
- authorization as admission, so a refused sender raises here."""
- import json
- from gateway.session_envelope import prepare_native, restore_native
- from gateway.session_ingress_media import abandon_capture, capture_lease
- with capture_lease(authority) as scope:
- try:
- payload = await prepare_native(authority.runner, event)
- except BaseException:
- await abandon_capture(scope)
- raise
- source = restore_native(payload).source
- identity = json.dumps([source.profile, source.platform.value, source.chat_id,
- source.thread_id, source.user_id], separators=(',', ':'))
- return payload, 'messaging:' + identity
- def _committed(authority, principal, request_id):
- """The rows of this delivery's identity in the FIFO."""
- return authority.db._read_all('SELECT admission_id FROM session_admissions '
- 'WHERE principal_id=? AND request_id=?', (principal, request_id))
- async def _webhook_retry(authority, event, payload, rows):
- # One-shot finalization ends the route. Resolve an existing provider receipt
- # before SessionStore would rotate it into a new physical session.
- from gateway.session_ingress_media import ingress_fingerprint
- from hermes_state_runtime import get_session_admission
- if not rows:
- return None
- row = get_session_admission(authority.db, admission_id=rows[0]['admission_id'])
- retained = row['payload']['native_text_v1']
- if 'ingress_sha256' in retained:
- # Committed rewritten: the provider resends the delivery as received.
- same = retained['ingress_sha256'] == ingress_fingerprint(payload, event.raw_message)
- else:
- if 'webhook_delivery' not in retained and 'webhook_route' not in retained:
- # A pre-destination receipt is still a receipt, not permission to infer
- # again. Do not retrofit today's destination into its queued execution.
- payload['native_text_v1'].pop('webhook_delivery')
- payload['native_text_v1'].pop('webhook_route')
- if 'provenance' not in retained:
- payload['native_text_v1'].pop('provenance', None)
- same = row['payload'] == payload
- if len(rows) != 1 or not same:
- raise RuntimeStoreError('admission_conflict')
- event._webhook_duplicate = True
- receipt = authority._receipt(row)
- finalize_webhook(authority, receipt)
- return receipt
- def finalize_webhook(authority, receipt):
- """End only the settled admitted generation, atomically with the epoch fence."""
- import time
- if receipt.status != 'terminal' or receipt.execution_generation is None:
- return False
- sid = receipt.ref.session_id
- def write(conn):
- return authority.db._end_and_bump(conn, """
- UPDATE sessions SET ended_at=?, end_reason=?
- WHERE id=? AND ended_at IS NULL AND runtime_generation=?
- AND EXISTS (SELECT 1 FROM runtime_epoch WHERE singleton=1 AND epoch=?)
- AND EXISTS (SELECT 1 FROM session_admissions WHERE admission_id=?
- AND target_session_id=? AND status='terminal' AND generation=? AND owner_epoch=?)
- AND NOT EXISTS (SELECT 1 FROM session_admissions WHERE target_session_id=? AND status!='terminal')
- """, (time.time(), 'webhook_complete', sid, receipt.execution_generation,
- authority.epoch, receipt.admission_id, sid, receipt.execution_generation,
- receipt.authority_epoch, sid), sid, 'webhook_complete')
- return bool(authority.db._execute_write(write))
- async def recover_webhook_finalizations(authority):
- """Close settled original webhooks only after current route authorization succeeds."""
- from gateway.session_envelope import check_native_route
- from gateway.session_contract import SessionRef
- from hermes_state_runtime import RuntimeStoreError, get_session_admission
- rows = authority.db._read_all("""
- SELECT a.admission_id FROM sessions AS s
- JOIN session_admissions AS a ON a.target_session_id=s.id
- WHERE s.source='webhook' AND s.ended_at IS NULL
- AND a.status='terminal' AND a.generation IS NOT NULL
- AND json_extract(a.payload_json, '$.native_text_v1.source.platform')='webhook'
- AND json_extract(a.payload_json, '$.native_text_v1.automation') IS NULL
- """)
- results = {}
- for candidate in rows:
- row = get_session_admission(authority.db, admission_id=candidate['admission_id'])
- if row is None:
- continue
- sid = row['target_session_id']
- try:
- envelope = row['payload']['native_text_v1']
- entry = authority.runner.session_store.lookup_by_session_key(envelope['route'])
- if entry is None or authority.logical_owner(entry.session_id) != sid:
- raise RuntimeStoreError('admission_conflict')
- adapter = authority.runner._adapter_for_source(entry.origin) if entry.origin is not None else None
- target = authority.physical_target(SessionRef(authority.profile_id, sid))
- await check_native_route(authority.runner, row['payload'], target, entry.origin, adapter)
- results[sid] = 'finalized' if finalize_webhook(
- authority, authority._receipt(row)) else 'unchanged'
- except (KeyError, RuntimeStoreError):
- results[sid] = 'unavailable'
- return results
|