Struct PushFanOut 

pub struct PushFanOut { /* private fields */ }

A PUSH endpoint that distributes messages across a pool of PULL workers.

Create one with bind, or bind a listener yourself and call accept_workers when you need the bound port before the workers connect (the bench peer does this to print its port).

Implementations

impl PushFanOut

pub async fn bind( addr: impl ToSocketAddrs, n_workers: usize, ) -> Result<(TcpListener, Self)>

Bind to addr, accept n_workers PULL connections, and return the listener alongside the ready fan-out socket.

The listener is returned so the caller can keep accepting late workers with accept if it wants to grow the pool.

Example

use monocoque::zmq::PushFanOut;
use bytes::Bytes;

let (_listener, mut vent) = PushFanOut::bind("127.0.0.1:5557", 4).await?;
for i in 0..100 {
    vent.send(vec![Bytes::from(format!("task-{i}"))]).await?;
}

pub async fn bind_with_options( addr: impl ToSocketAddrs, n_workers: usize, options: SocketOptions, ) -> Result<(TcpListener, Self)>

Like bind but applies options to every worker connection.

pub async fn accept_workers( listener: &TcpListener, n_workers: usize, options: SocketOptions, ) -> Result<Self>

Accept n_workers PULL connections on an already-bound listener.

Useful when the bound address must be read (and announced) before the workers are allowed to connect.

pub async fn accept(&mut self, listener: &TcpListener) -> Result<()>

Accept one more worker on listener and add it to the pool.

pub fn len(&self) -> usize

Number of workers currently in the pool.

pub fn is_empty(&self) -> bool

True when no workers remain.

pub async fn send(&mut self, msg: Vec<Bytes>) -> Result<()>

Send one message to the next worker in round-robin order.

Workers already known to be disconnected are skipped (and dropped from the pool) before the message is handed over, so a send that fails mid-flight only fails the current call; the failed worker is routed around from the next send onward. The call only errors when no live worker remains.

The message bodies stay zero-copy (Bytes are refcounted) and the healthy path moves msg straight into the chosen worker, so it adds no per-message allocation over a plain PushSocket::send.

pub async fn send_one(&mut self, frame: Bytes) -> Result<()>

Send one single-frame message to the next worker in round-robin order.

Equivalent to send(vec![frame]), but avoids the per-message multipart container allocation in single-frame hot paths.

pub async fn flush(&mut self) -> Result<()>

Flush every worker’s write-coalescing buffer.

Call this after the last send in a burst when the workers were created with write coalescing enabled.