Struct RemoteChannelHandle 

pub struct RemoteChannelHandle { /* private fields */ }

Channel handle that communicates through SDK-internal wire protocol transport.

The handle inherits whatever transport its RemoteConfig carries. A config straight out of RemoteConfig::new has never been connected, so every operation on a handle built from it refuses with SdkError::NotConnected rather than reporting a success that reached no wire. Connect the config first.

Implementations

impl RemoteChannelHandle

pub fn negotiated_version(&self) -> Option<ProtocolVersion>

The protocol version the server selected in the current connection’s ConnectAck, or None before a handshake has completed (including on the in-process protocol transport, which never opens a connection).

impl RemoteChannelHandle

pub fn new(config: &RemoteConfig) -> Result<Self, SdkError>

Creates a remote channel handle from validated configuration.

Errors

Returns SdkError if the connection pool cannot be created.

pub fn connection_state(&self) -> ConnectionState

Returns current lifecycle state from the SDK-003 state machine.

pub fn reconnect_started(&self) -> Result<(), SdkError>

Records that an externally authorized real reconnect attempt started.

Errors

Returns SdkError when the lifecycle rejects the transition.

pub fn connected(&self) -> Result<Vec<ResumeRequest>, SdkError>

Marks the remote channel connected and builds subscription resume requests.

Errors

Returns SdkError if lifecycle transition or recovery state is invalid.

pub fn track_subscription(&self) -> Result<SubscriptionId, SdkError>

Marks a subscription active and assigns it to the configured pool.

Errors

Returns SdkError if a subscription id overflows or pool assignment fails.

pub fn acknowledge( &self, subscription_id: SubscriptionId, sequence: u64, ) -> Result<(), SdkError>

Records an acknowledged sequence for subscription recovery.

Errors

Returns SdkError if the subscription is not active in the pool.

pub const fn server_address(&self) -> &ServerAddress

Returns remote server address used by this handle.

impl RemoteChannelHandle

pub fn publish_with_idempotency_key<M>( &self, message: &M, idempotency_key: &str, ) -> Result<DeliveryAck, SdkError>

where M: Serialize + SchemaValidate,

Publishes a message with an idempotency key and returns a genuine delivery ack.

The idempotency key drives dedup-on-delivery on the server: a re-publish of the same key is delivered to subscribers at most once. The returned DeliveryAck reports whether this publish was genuinely accepted by a subscriber (DeliveryAck::is_accepted), which a caller such as the aion outbox uses to treat the send as done only on real acceptance. This is distinct from the backpressure-only publish.

Errors

Returns SdkError when the message cannot be serialized, the round trip fails, or the transport cannot produce a genuine delivery ack.

Only with std: without it no transport could carry the key, so no keyed publish is offered rather than one that drops the key (Hermes 7 Oct 08:32).

pub fn reply_to<M>( &self, request: Option<DeliveredId>, message: &M, ) -> Result<DeliveryAck, SdkError>

where M: Serialize + SchemaValidate,

Publishes message as the reply to request and returns a genuine delivery ack (Fable 4c).

request is the id a delivered message carried (DeliveredMessage::message): the reply names it as its causal parent, <boot>:<id>, so the server’s tap can pair the two and measure the dwell between them. A request that carried no id (a server before protocol 1.2, or a durable message replayed from the store) gives a reply with no parent, never an invented one.

Errors

Returns SdkError when the message cannot be serialized, the round trip fails, or the transport cannot produce a genuine delivery ack.

Trait Implementations

impl ChannelHandle for RemoteChannelHandle

fn subscribe<M>(&self) -> Self::Subscription<M>

where M: DeserializeOwned,

REFUSES. Typed subscription delivery is not implemented on this handle.

The returned stream yields exactly one item — Err(SdkError::Unwired) — and then ends. It does not touch the transport, so no Subscribe is left outstanding on the server for a stream that could never deliver.

What this replaces was worse than unimplemented. The old body performed the real wire Subscribe, registered a subscription in the pool, and then returned SdkSubscription::empty() — a stream whose poll_next is Ready(None) immediately and forever. A caller’s while let Some(m) = sub.next().await exited on the first poll while the server pumped Deliver frames at a connection nothing was reading.

For real delivery use the lower-level surface that works today: SubscriptionStream::open plus SubscriptionStream::recv_timeout (or WebSocketSubscriptionStream::open on the WebSocket transport).

type Subscription<M> = SdkSubscription<M> where M: DeserializeOwned

Stream returned by subscribe for message type M.

type ReplyFuture<'a, Resp> = ReadyResult<Resp> where Self: 'a, Resp: DeserializeOwned + 'a

Future returned by request_reply for reply type Resp.

fn publish<M>(&self, message: M) -> Result<PressureResponse, SdkError>

where M: Serialize + SchemaValidate,

Publishes a typed message to the channel.

fn request_reply<Req, Resp>(&self, request: Req) -> ReadyResult<Resp>

where Req: Serialize + SchemaValidate, Resp: DeserializeOwned,

Sends a typed request and resolves with a typed reply.

impl Clone for RemoteChannelHandle

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RemoteChannelHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.