inbound_admission.py 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
  1. """Native admission of a connector-delivered relay message (``RelayAdapter._on_inbound``)."""
  2. import asyncio
  3. import logging
  4. from hermes_state_runtime import RuntimeStoreError
  5. logger = logging.getLogger("gateway.relay.adapter")
  6. async def admit_relay_delivery(adapter, runner, event):
  7. """Admit *event*; the transport ACKs the frame once this returns, or once the returned task does.
  8. Without producer hooks admission waits only for the SQLite receipt, on the socket reader. With
  9. one, ``pre_gateway_dispatch`` or ``post_gateway_admission`` plugin code runs before the commit and
  10. may await ``adapter.send()``, whose ``outbound_result`` only that reader delivers, or wait for
  11. another inbound message: the admission then runs in a task off the reader, after any earlier
  12. admission of the same chat, so one chat's deliveries still commit in arrival order."""
  13. from gateway.run_inbound_consumer import POST_ADMISSION_HOOK
  14. from hermes_cli.lifecycle import has_hook
  15. if not (has_hook('pre_gateway_dispatch') or has_hook(POST_ADMISSION_HOOK)):
  16. await _admit(adapter, runner, event)
  17. return None
  18. lanes = adapter._admission_lanes
  19. lane = (event.source.platform.value, event.source.chat_id)
  20. task = asyncio.create_task(_admit_after(lanes.get(lane), adapter, runner, event))
  21. lanes[lane] = task
  22. task.add_done_callback(lambda done: lanes.pop(lane) if lanes.get(lane) is done else None)
  23. adapter._background_tasks.add(task) # cancelled with the adapter's work on shutdown
  24. task.add_done_callback(adapter._background_tasks.discard)
  25. return task
  26. async def _admit_after(previous, adapter, runner, event):
  27. if previous is not None:
  28. await asyncio.wait([previous]) # its outcome is its own frame's ACK, not this one's
  29. await _admit(adapter, runner, event)
  30. async def _admit(adapter, runner, event):
  31. # A permanent refusal returns, so the transport ACKs it (a replay would be refused again: main's
  32. # runner dropped it too); any other failure withholds the ACK so the connector redelivers. A
  33. # parked target is refused to the sender and ACKed: it stays parked until a rescan or a restart,
  34. # and a withheld frame would stall the connector's ordered, ack-gated buffer drain for every
  35. # profile on this instance (a live frame is never redelivered anyway).
  36. from gateway.parked_route_refusal import ParkedProfileRefusal, refuse_parked_route
  37. from gateway.platforms.webhook_ingress import admit_producer
  38. from gateway.relay.adapter import _PERMANENT_REFUSALS
  39. try:
  40. receipt = await admit_producer(adapter, event)
  41. except ParkedProfileRefusal as exc:
  42. refuse_parked_route(adapter, event.source, exc.profile, reply_to=event.message_id)
  43. return
  44. except RuntimeStoreError as exc:
  45. if exc.reason not in _PERMANENT_REFUSALS:
  46. raise
  47. logger.warning("relay inbound refused (%s) for %s chat=%s; acknowledged, not replayed",
  48. exc.reason, event.source.platform.value, event.source.chat_id)
  49. return
  50. if receipt is None and getattr(event, '_consumer_reply', None):
  51. # A post_gateway_admission plugin consumed it (never committed); its reply is
  52. # sent off this reader, like an executed admission's.
  53. from gateway.session_ingress import deliver_response
  54. task = asyncio.create_task(deliver_response(
  55. adapter, event, runner._session_key_for_source(event.source), event._consumer_reply))
  56. adapter._background_tasks.add(task)
  57. task.add_done_callback(adapter._background_tasks.discard)