Struct libzmq::Radio

pub struct Radio { /* fields omitted */ }

A Radio socket is used by a publisher to distribute data to Dish sockets.

Each message belong to a group specified with set_group. Messages are distributed to all members of a group.

Mute State

When a Radio socket enters the mute state due to having reached the high water mark for a subscriber, then any messages that would be sent to the subscriber in question shall instead be dropped until the mute state ends.

Summary of Characteristics

Characteristic	Value
Compatible peer sockets	Dish
Direction	Unidirectional
Send/receive pattern	Send only
Incoming routing strategy	N/A
Outgoing routing strategy	Fan out
Action in mute state	Drop

Example

use libzmq::{prelude::*, *};
use std::{convert::TryInto, thread, time::Duration};

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

let radio = RadioBuilder::new()
    .bind(addr)
    .build()?;

let bound = radio.last_endpoint().unwrap();
let a: &Group = "A".try_into()?;
let b: &Group = "B".try_into()?;

let dish_a = DishBuilder::new()
    .connect(&bound)
    .join(a)
    .build()?;

let dish_b = DishBuilder::new()
    .connect(bound)
    .join(b)
    .build()?;

// Start the feed. It has no conceptual start nor end, thus we
// don't synchronize with the subscribers.
thread::spawn(move || {
    let a: &Group = "A".try_into().unwrap();
    let b: &Group = "B".try_into().unwrap();
    let mut count = 0;
    loop {
        let mut msg = Msg::new();
        // Alternate between the two groups.
        let group = {
            if count % 2 == 0 {
                a
            } else {
                b
            }
        };

        msg.set_group(group);
        radio.send(msg).unwrap();

        thread::sleep(Duration::from_millis(1));
        count += 1;
    }
});

// Each dish will only receive the messages from their respective groups.
let msg = dish_a.recv_msg()?;
assert_eq!(msg.group().unwrap(), a);

let msg = dish_b.recv_msg()?;
assert_eq!(msg.group().unwrap(), b);

Methods

impl Radio

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

Create a Radio socket from the global context

Returned Error Variants

• CtxTerminated
• SocketLimit

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

Create a Radio 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 no_drop(&self) -> Result<bool, Error>

Returns true if the no_drop option is set.

pub fn set_no_drop(&self, enabled: bool) -> Result<(), Error>

Sets the socket's behaviour to block instead of drop messages when in the mute state.

Default value

false

Trait Implementations

impl SendMsg for Radio

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<Option<i32>, Error>

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

fn set_send_high_water_mark(&self, maybe: Option<i32>) -> Result<(), Error>

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

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

Sets the timeout for [send] on the socket.

fn set_send_timeout(&self, maybe: Option<Duration>) -> Result<(), Error>

Sets the timeout for [send] on the socket.

impl Socket for Radio

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 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 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 unbind<I, E>(&self, endpoints: I) -> Result<(), Error<usize>> where
    I: IntoIterator<Item = E>,
    E: Into<Endpoint>, 

Unbinds the socket from one or more [Endpoints].

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

Retrieve the last endpoint connected or bound to.

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

Retrieve the maximum length of the queue of outstanding peer connections.

fn set_backlog(&self, value: i32) -> Result<(), Error>

Set the maximum length of the queue of outstanding peer connections for the specified socket; this only applies to connection-oriented transports.

fn heartbeat_interval(&self) -> Result<Duration, Error>

The interval between sending ZMTP heartbeats.

fn set_heartbeat_interval(&self, duration: Duration) -> Result<(), Error>

Sets the interval between sending ZMTP PINGs (aka. heartbeats).

fn heartbeat_timeout(&self) -> Result<Duration, Error>

How long to wait before timing-out a connection after sending a PING ZMTP command and not receiving any traffic.

fn set_heartbeat_timeout(&self, duration: Duration) -> Result<(), Error>

How long to wait before timing-out a connection after sending a PING ZMTP command and not receiving any traffic.

fn heartbeat_ttl(&self) -> Result<Duration, Error>

The timeout on the remote peer for ZMTP heartbeats. If this option and heartbeat_interval is not None the remote side shall time out the connection if it does not receive any more traffic within the TTL period.

fn set_heartbeat_ttl(&self, duration: Duration) -> Result<(), Error>

Set timeout on the remote peer for ZMTP heartbeats. If this option and heartbeat_interval is not None the remote side shall time out the connection if it does not receive any more traffic within the TTL period.

fn linger(&self) -> Result<Option<Duration>, Error>

Returns the linger period for the socket shutdown.

fn set_linger(&self, maybe: Option<Duration>) -> Result<(), Error>

Sets the linger period for the socket shutdown.

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::};

impl Sync for Radio

impl Send for Radio

impl PartialEq<Radio> for Radio

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

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

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

This method tests for !=.

impl Clone for Radio

fn clone(&self) -> Radio

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Eq for Radio

impl Debug for Radio

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

Formats the value using the given formatter.