pub struct SessionMessenger { /* private fields */ }Expand description
Validates logical identity, atomically enqueues, then requests one runtime activation. The service owns no process-global registry.
Implementations§
Source§impl SessionMessenger
impl SessionMessenger
pub fn new( sessions: Arc<dyn Storage>, inbox: Arc<dyn SessionInboxPort>, activation: Arc<dyn SessionActivationPort>, ) -> Self
pub fn inbox(&self) -> &Arc<dyn SessionInboxPort> ⓘ
pub fn activation(&self) -> &Arc<dyn SessionActivationPort> ⓘ
pub fn metrics(&self) -> &Arc<SessionMessagingMetrics> ⓘ
Sourcepub async fn list_peer_targets(
&self,
caller_session_id: &str,
) -> Result<SessionPeerTargets, SessionMessengerError>
pub async fn list_peer_targets( &self, caller_session_id: &str, ) -> Result<SessionPeerTargets, SessionMessengerError>
Discover bounded logical peers in the caller’s current canonical tree.
caller_session_id comes from the authenticated runtime context, never
from model arguments. Every candidate is revalidated before disclosure.
Sourcepub async fn send_peer(
&self,
caller_session_id: &str,
target_session_id: &str,
operation_id: &str,
message: &str,
) -> Result<SessionMessengerReceipt, SessionMessengerError>
pub async fn send_peer( &self, caller_session_id: &str, target_session_id: &str, operation_id: &str, message: &str, ) -> Result<SessionMessengerReceipt, SessionMessengerError>
Send an asynchronous peer instruction. Source identity and association fields are constructed by the runtime; callers provide no envelope. Reuse the same operation id and message after an uncertain result.
Sourcepub async fn reply_peer(
&self,
caller_session_id: &str,
received_message_id: &str,
operation_id: &str,
message: &str,
) -> Result<SessionMessengerReceipt, SessionMessengerError>
pub async fn reply_peer( &self, caller_session_id: &str, received_message_id: &str, operation_id: &str, message: &str, ) -> Result<SessionMessengerReceipt, SessionMessengerError>
Reply only to a canonical received peer envelope in the caller’s saved transcript. Recipient and thread edges are never supplied by the model.
Sourcepub async fn supervisor_followup(
&self,
supervisor: &SupervisorReference,
target_session_id: &str,
operation_id: &str,
message: &str,
) -> Result<SessionMessengerReceipt, SessionMessengerError>
pub async fn supervisor_followup( &self, supervisor: &SupervisorReference, target_session_id: &str, operation_id: &str, message: &str, ) -> Result<SessionMessengerReceipt, SessionMessengerError>
Follow an already-attached Ordinary Root from the original executing Supervisor. The concrete inbox revalidates and retains all authority locks through durable admission; a prior inspect_link is never a grant.
pub async fn admit( &self, envelope: SessionMessageEnvelope, ) -> Result<SessionMessengerAdmission, SessionMessengerError>
pub async fn admit_with_gate( &self, envelope: SessionMessageEnvelope, gate: Option<&AdmissionGate>, ) -> Result<SessionMessengerAdmission, SessionMessengerError>
Sourcepub async fn admit_with_activation_intent(
&self,
envelope: SessionMessageEnvelope,
policy: SessionActivationPolicy,
gate: Option<&AdmissionGate>,
) -> Result<SessionMessengerAdmission, SessionMessengerError>
pub async fn admit_with_activation_intent( &self, envelope: SessionMessageEnvelope, policy: SessionActivationPolicy, gate: Option<&AdmissionGate>, ) -> Result<SessionMessengerAdmission, SessionMessengerError>
Commit this specific message’s immediate permission together with the
envelope. Coordinators continue to use staged admit.
pub async fn activate( &self, admission: &SessionMessengerAdmission, ) -> Result<SessionMessengerReceipt, SessionMessengerError>
pub async fn activate_with_policy( &self, admission: &SessionMessengerAdmission, policy: SessionActivationPolicy, ) -> Result<SessionMessengerReceipt, SessionMessengerError>
Sourcepub async fn activate_prepared(
&self,
admission: &SessionMessengerAdmission,
) -> Result<SessionMessengerReceipt, SessionMessengerError>
pub async fn activate_prepared( &self, admission: &SessionMessengerAdmission, ) -> Result<SessionMessengerReceipt, SessionMessengerError>
Request execution for an admission whose activation policy was already durably recorded by a coordinator.
Sourcepub async fn prepare_activation(
&self,
admission: &SessionMessengerAdmission,
) -> Result<(), SessionMessengerError>
pub async fn prepare_activation( &self, admission: &SessionMessengerAdmission, ) -> Result<(), SessionMessengerError>
Durably authorize the admitted queue prefix before a related control-plane transition is committed.
Coordinators call this while their specific wait is still armed, then
checkpoint the wait clear, and finally call activate.
A crash in either gap is recoverable: startup sees the watermark, while
the real reservation adapter refuses to run until the specific wait has
been durably cleared.
Sourcepub async fn prepare_message_activation(
&self,
admission: &SessionMessengerAdmission,
policy: SessionActivationPolicy,
) -> Result<(), SessionMessengerError>
pub async fn prepare_message_activation( &self, admission: &SessionMessengerAdmission, policy: SessionActivationPolicy, ) -> Result<(), SessionMessengerError>
Authorize one staged delivery, preserving its immutable delivery intent and every sibling’s existing execution permission.