Struct libzmq::Client

pub struct Client { /* fields omitted */ }

A Client socket is used for advanced request-reply messaging.

Client sockets are threadsafe and can be used from multiple threads at the same time. Note that replies from a Server socket will go to the first client thread that calls recv. If you need to get replies back to the originating thread, use one Client socket per thread.

When a Client socket is connected to multiple sockets, outgoing messages are distributed between connected peers on a round-robin basis. Likewise, the Client socket receives messages fairly from each connected peer.

Mute State

When Client socket enters the mute state due to having reached the high water mark, or if there are no peers at all, then any send operations on the socket shall block until the mute state ends or at least one peer becomes available for sending; messages are not discarded.

Summary of Characteristics

Characteristic	Value
Compatible peer sockets	Server
Direction	Bidirectional
Send/receive pattern	Unrestricted
Outgoing routing strategy	Round-robin
Incoming routing strategy	Fair-queued
Action in mute state	Block

Example

use libzmq::{prelude::*, *};

// Use a system assigned port.
let addr: TcpAddr = "127.0.0.1:*".try_into()?;

let server = ServerBuilder::new()
    .bind(addr)
    .build()?;

// Retrieve the addr that was assigned.
let bound = server.last_endpoint()?;

let client = ClientBuilder::new()
    .connect(bound)
    .build()?;

// Send a string request.
client.send("tell me something")?;

// Receive the client request.
let msg = server.recv_msg()?;
let id = msg.routing_id().unwrap();

// Reply to the client.
server.route("it takes 224 bits to store a i32 in java", id)?;

// We send as much replies as we want.
server.route("also don't talk to me", id)?;

// Retreive the first reply.
let mut msg = client.recv_msg()?;
// And the second.
client.recv(&mut msg)?;

Implementations

impl Client

pub fn new() -> Result<Self, Error>

Create a Client socket from the global context

Returned Error Variants

• InvalidCtx
• SocketLimit

pub fn with_ctx(handle: CtxHandle) -> Result<Self, Error>

Create a Client socket associated with a specific context from a CtxHandle.

Returned Error Variants

• InvalidCtx
• SocketLimit

pub fn ctx(&self) -> CtxHandle

Returns the handle to the Ctx of the socket.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.

impl Eq for Client

impl<'a> From<&'a Client> for Pollable<'a>

fn from(client: &'a Client) -> Self

Performs the conversion.

impl Heartbeating for Client

fn heartbeat(&self) -> Option<Heartbeat>

Returns a the socket's heartbeating configuration.

fn set_heartbeat(&self, maybe: Option<Heartbeat>) -> Result<(), Error>

Sets the socket's heartbeating configuration.

impl PartialEq<Client> for Client

fn eq(&self, other: &Client) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Client) -> bool

This method tests for !=.

impl RecvMsg for Client

fn recv(&self, msg: &mut Msg) -> Result<(), Error>

Retreive a message from the inbound socket queue.

fn try_recv(&self, msg: &mut Msg) -> Result<(), Error>

Try to retrieve a message from the inbound socket queue without blocking.

fn recv_msg(&self) -> Result<Msg, Error>

A convenience function that allocates a [Msg] with the same properties as [recv].

fn try_recv_msg(&self) -> Result<Msg, Error>

A convenience function that allocates a [Msg] with the same properties as [try_recv].

fn recv_hwm(&self) -> Result<i32, Error>

The high water mark for incoming messages on the specified socket.

fn set_recv_hwm(&self, hwm: i32) -> Result<(), Error>

Set the high water mark for inbound messages on the specified socket.

fn recv_timeout(&self) -> Result<Period, Error>

The timeout for [recv] on the socket.

fn set_recv_timeout<P>(&self, period: P) -> Result<(), Error> where
    P: Into<Period>, 

Sets the timeout for [recv] on the socket.

impl Send for Client

impl SendMsg for Client

fn send<M>(&self, msg: M) -> Result<(), Error<Msg>> where
    M: Into<Msg>, 

Push a message into the outgoing socket queue.

fn try_send<M>(&self, msg: M) -> Result<(), Error<Msg>> where
    M: Into<Msg>, 

Try to push a message into the outgoing socket queue without blocking.

fn send_hwm(&self) -> Result<i32, Error>

The high water mark for outbound messages on the specified socket.

fn set_send_hwm(&self, hwm: i32) -> Result<(), Error>

Set the high water mark for outbound messages on the specified socket.

fn send_timeout(&self) -> Result<Period, Error>

Sets the timeout for [send] on the socket.

fn set_send_timeout<P>(&self, period: P) -> Result<(), Error> where
    P: Into<Period>, 

Sets the timeout for [send] on the socket.

impl Socket for Client

fn connect<E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Schedules a connection to a Endpoint.

fn bind<E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Schedules a bind to a Endpoint and then accepts incoming connections.

fn disconnect<E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Disconnect the socket from a Endpoint.

fn unbind<I, E>(&self, endpoint: E) -> Result<(), Error> where
    E: Into<Endpoint>, 

Unbind the socket from a Endpoint.

fn last_endpoint(&self) -> Result<Endpoint, Error>

Retrieve the last endpoint connected or bound to.

fn mechanism(&self) -> Mechanism

Returns the socket's [Mechanism].

fn set_mechanism<M>(&self, mechanism: M) -> Result<(), Error> where
    M: Into<Mechanism>, 

Set the socket's [Mechanism].

impl StructuralEq for Client

impl StructuralPartialEq for Client

impl Sync for Client