Struct ConnectedZmqRpc 

pub struct ConnectedZmqRpc { /* private fields */ }

The connected form of ZmqRpc.

Implementations

impl ConnectedZmqRpc

pub fn bound_address(&self) -> Option<String>

The address the responder resolved by binding (useful with an ephemeral tcp://...:0 endpoint); None until a subscription has bound.

pub fn publisher(&self) -> ZmqRpcPublisher

A publisher from the connected form.

Trait Implementations

impl ConnectedBroker for ConnectedZmqRpc

type Error = ZmqError

The error type returned by connected-broker operations.

type Closed = ()

The terminal witness returned by shutdown.

fn shutdown(self) -> impl Future<Output = Result<(), Self::Error>>

Closes the broker connection, flushing in-flight publishes and stopping background tasks, consuming the connected form.

impl Debug for ConnectedZmqRpc

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

Formats the value using the given formatter.

impl DefaultPublish for ConnectedZmqRpc

type Policy = ZmqRpcPublish

The broker’s plain publish policy, constructible with its defaults.

impl PublishPolicy<ConnectedZmqRpc> for ZmqRpcPublish

fn channel_bindings(&self, channel: &str) -> Bindings

The destination reaches the binding and stays out of it: a reply travels to the identity the ROUTER supplies, so no name on this channel is an address a peer can send to.

type Live = ZmqRpcPublisher

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

fn pair( self, connected: &ConnectedZmqRpc, ) -> impl Future<Output = Result<Self::Live, PairError>>

Pairs the policy with a connected broker, producing the live publisher.

fn reply_address_location(&self) -> Option<&'static str>

Where a client finds the address of a reply this policy publishes, as a runtime expression.

fn operation_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to its send operation in the document.

fn message_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to the messages that leave through it.

impl Subscribe for ConnectedZmqRpc

type Copies = NamedCopies

A copy of a request has no address of its own, so the mount site names where one goes.

The name a responder subscribes under is not a publish destination on this pattern: ZmqRpcPublisher routes to the peer identity a request carried and refuses a plain name, so a copy published under the subscription name would reach nothing. A registration that binds .out_retry(..) over a responder therefore has to say where the copies go, with .to("name") or with a transform that names one per delivery, and one that says neither is refused before the subscription opens. Ask a requester again rather than retrying its request from the responder side.

type Subscriber = ZmqRpcSubscriber

The subscriber type opened by a by-name subscription.

async fn subscribe(&self, name: &str) -> Result<Self::Subscriber, Self::Error>

Opens a subscription to name, producing this broker’s Subscriber.

fn declare_retry( &self, name: &str, declaration: &RetryDeclaration, ) -> Result<(), DeclareRetryError>

Takes what a registration mounted by a bare name declared about its retries, before the subscription opens.

impl TestableBroker for ConnectedZmqRpc

The exchange’s routing: a request reaches the responder that binds the endpoint, or one of the responders that dial it in turn, stamped with the peer that asked; an answer reaches that peer and no subscription.

fn install_coordinator(&self, coordinator: Coordinator)

Installs the harness coordinator into this broker’s bus for a test run. Idempotent: a second install on the same broker is ignored.

fn inject(&self, message: OutgoingMessage<'_>)

Injects a message onto the bus as an external producer would, synchronously (no awaiting). Routes through the broker’s normal fanout, so it is recorded and counted like any publish.

fn published(&self, name: &str) -> Vec<RawMessage>

Returns every message published to name on this broker, in publish order, after the evicted ones. Backs the harness’s published::<T>(name) assertions and expect_published.

fn routes(&self, destination: &str, subscriptions: &[&str]) -> Vec<usize>

Which subscriptions of this broker a message published to destination is delivered to, as the broker’s own routing picks them: the positions in subscriptions (the names the app subscribed under on this broker) of the ones it delivers to.

fn evicted(&self, name: &str) -> usize

How many of the oldest messages published to name this broker no longer holds, so published starts after them.

fn backlog(&self) -> Backlog

What a subscription opened by name receives of the messages published to that name before it opened, as the real broker answers it: Backlog::Missed for publish/subscribe, Backlog::Delivered for a queue or a log that keeps them.