Struct PushSocket 

pub struct PushSocket<S = TcpStream>
where
    S: AsyncRead + AsyncWrite + Unpin,
{ /* private fields */ }

PUSH socket for distributing tasks in a pipeline.

PUSH sockets send messages in a round-robin fashion to connected PULL sockets.

Implementations

impl PushSocket<TcpStream>

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

Bind to addr, accept one connection, and return a ready PUSH socket.

Returns the TcpListener so the caller can accept further PULL connections.

Example

use monocoque::zmq::PushSocket;
use bytes::Bytes;

let (_listener, mut socket) = PushSocket::bind("127.0.0.1:5555").await?;
socket.send(vec![Bytes::from("task")]).await?;

pub async fn connect(addr: impl ToSocketAddrs) -> Result<Self>

Connect to a PULL socket at addr.

Example

use monocoque::zmq::PushSocket;
use bytes::Bytes;

let mut socket = PushSocket::connect("127.0.0.1:5555").await?;
socket.send(vec![Bytes::from("task")]).await?;

pub async fn connect_with_options( addr: impl ToSocketAddrs, options: SocketOptions, ) -> Result<Self>

Connect with custom options, storing the endpoint for automatic reconnection.

pub fn is_connected(&self) -> bool

Check if the socket is currently connected.

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

Try to reconnect to the stored endpoint.

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

Send with automatic reconnection on network error.

pub async fn from_tcp(stream: TcpStream) -> Result<Self>

Create a PUSH socket from a TCP stream.

pub async fn from_tcp_with_options( stream: TcpStream, options: SocketOptions, ) -> Result<Self>

Create a PUSH socket from a TCP stream with custom options.

impl<S> PushSocket<S>

where S: AsyncRead + AsyncWrite + Unpin,

pub async fn new(stream: S) -> Result<Self>

Create a PUSH socket from any stream.

pub async fn with_options(stream: S, options: SocketOptions) -> Result<Self>

Create a PUSH socket from any stream with custom options.

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

Send a message.

By default each call writes to the kernel immediately (eager mode). For throughput-bound pipelines, enable write coalescing via SocketOptions::with_write_coalescing and call flush after the last send in each burst. See docs/performance.md for measured numbers and an explanation of when each mode is appropriate.

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

Send a single-frame message without allocating a multipart Vec.

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

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

Flush any messages still buffered by write coalescing.

Required after the last send() in a burst when write_coalescing is enabled. In coalesced mode, bytes accumulate in a userspace buffer and are not guaranteed to reach the peer until this is called (or the 64 KB threshold fills naturally). Has no effect in eager mode (the default).

pub async fn send_batch<I>(&mut self, msgs: I) -> Result<usize>

where I: IntoIterator<Item = Vec<Bytes>>,

Send a batch of messages in a single kernel write.

Encodes all messages into the send buffer and flushes once, regardless of whether write_coalescing is enabled. Use this when you have a collection of messages ready to send and want to minimize syscall count without managing flush() calls manually:

use bytes::Bytes;
let batch: Vec<Vec<Bytes>> = (0..100)
    .map(|i| vec![Bytes::from(format!("msg-{i}").into_bytes())])
    .collect();
push.send_batch(batch).await?;

Returns the number of messages sent.

pub fn monitor(&mut self) -> SocketMonitor

Enable monitoring for this socket.

pub fn options_mut(&mut self) -> &mut SocketOptions

Get a mutable reference to this socket’s options.

impl PushSocket<UnixStream>

pub async fn from_unix_stream(stream: UnixStream) -> Result<Self>

Create a PUSH socket from a Unix domain socket stream (IPC).

pub async fn from_unix_stream_with_options( stream: UnixStream, options: SocketOptions, ) -> Result<Self>

Create a PUSH socket from a Unix domain socket stream with custom options.