Struct libzmq::Server

pub struct Server { /* fields omitted */ }

A Server socket is a socket used for advanced request-reply messaging.

A Server socket talks to a set of Client sockets. The Client must first initiate the conversation, which generates a routing_id associated with the connection. Each message received from a Server will have this routing_id. To send messages back to the server, you must associate them to a RoutingId either manually using set_routing_id or via the route convenience method. If the routing_id is not specified, or does not refer to a connected server peer, the send call will fail with HostUnreachable.

Mute State

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

Summary of Characteristics

Characteristic	Value
Compatible peer sockets	Server
Direction	Bidirectional
Pattern	Unrestricted
Incoming routing strategy	Fair-queued
Outgoing routing strategy	See text
Action in mute state	Block

Example

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

let addr: TcpAddr = "127.0.0.1:*".try_into()?;

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

let bound = server.last_endpoint()?;

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

// The client initiates the conversation so it is assigned a `routing_id`.
client.send("request")?;
let msg = server.recv_msg()?;
assert_eq!("request", msg.to_str()?);
let id = msg.routing_id().unwrap();

// Using this `routing_id`, we can now route as many replies as we
// want to the client.
server.route("reply 1", id)?;
server.route("reply 2", id)?;

// The `routing_id` is discarted when the message is sent to the client.
let mut msg = client.recv_msg()?;
assert_eq!("reply 1", msg.to_str()?);
assert!(msg.routing_id().is_none());
client.recv(&mut msg)?;
assert_eq!("reply 2", msg.to_str()?);
assert!(msg.routing_id().is_none());

Methods

impl Server

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

Create a Server socket from the global context

Returned Error Variants

• CtxTerminated
• SocketLimit

pub fn with_ctx<C>(ctx: C) -> Result<Server, Error> where
    C: Into<Ctx>, 

Create a Server socket from a specific context.

Returned Error Variants

• CtxTerminated
• SocketLimit

pub fn ctx(&self) -> &Ctx

Returns a reference to the context of the socket.

pub fn route<M>(&self, msg: M, id: RoutingId) -> Result<(), Error<Msg>> where
    M: Into<Msg>, 

Push a message into the outgoing socket queue with the specified RoutingId.

This is a convenience function that sets the Msg's RoutingId then sends it.

See send for more information.

pub fn try_route<M>(&self, msg: M, id: RoutingId) -> Result<(), Error<Msg>> where
    M: Into<Msg>, 

Try to push a message into the outgoing socket queue with the specified RoutingId.

This is a convenience function that sets the Msg's RoutingId then tries sends it.

See try_send for more information.

Trait Implementations

impl RecvMsg for Server

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_high_water_mark(&self) -> Result<Quantity, Error>

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

fn set_recv_high_water_mark<Q>(&self, qty: Q) -> Result<(), Error> where
    Q: Into<Quantity>, 

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 SendMsg for Server

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_high_water_mark(&self) -> Result<Quantity, Error>

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

fn set_send_high_water_mark<Q>(&self, qty: Q) -> Result<(), Error> where
    Q: Into<Quantity>, 

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 Server

fn connect<I, E>(&self, endpoints: I) -> Result<(), Error<usize>> where
    I: IntoIterator<Item = E>,
    E: Into<Endpoint>, 

Schedules a connection to one or more [Endpoints] and then accepts incoming connections.

fn bind<I, E>(&self, endpoints: I) -> Result<(), Error<usize>> where
    I: IntoIterator<Item = E>,
    E: Into<Endpoint>, 

Schedules a bind to one or more [Endpoints] and then accepts incoming connections.

fn disconnect<I, E>(&self, endpoints: I) -> Result<(), Error<usize>> where
    I: IntoIterator<Item = E>,
    E: Into<Endpoint>, 

Disconnect the socket from one or more [Endpoints].

fn last_endpoint(&self) -> Result<Option<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]. # Example ``` # use failure::Error; # # fn main() -> Result<(), Error> { use libzmq::{prelude::, Client, auth::};

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

Returns a the socket's heartbeat configuration.

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

Set the socket's heartbeat configuration.

impl Sync for Server

impl Eq for Server

impl Send for Server

impl PartialEq<Server> for Server

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

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

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

This method tests for !=.

impl Clone for Server

fn clone(&self) -> Server

Returns a copy of the value.

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

Performs copy-assignment from source.

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

fn from(server: &'a Server) -> Self

Performs the conversion.

impl Debug for Server

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

Formats the value using the given formatter.