Struct PullSocket 

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

PULL socket for receiving tasks in a pipeline.

PULL sockets receive messages from connected PUSH sockets.

Implementations

impl PullSocket<TcpStream>

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

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

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

Example

use monocoque::zmq::PullSocket;

let (_listener, mut socket) = PullSocket::bind("127.0.0.1:5555").await?;
while let Ok(Some(msg)) = socket.recv().await {
    println!("Got task: {:?}", msg);
}

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

Connect to a PUSH socket at addr.

Example

use monocoque::zmq::PullSocket;

let mut socket = PullSocket::connect("127.0.0.1:5555").await?;
while let Ok(Some(msg)) = socket.recv().await {
    println!("Got task: {:?}", msg);
}

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 recv_with_reconnect(&mut self) -> Result<Option<Vec<Bytes>>>

Receive with automatic reconnection on EOF or network error.

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

Create a PULL socket from a TCP stream.

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

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

impl<S> PullSocket<S>

where S: AsyncRead + AsyncWrite + Unpin,

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

Create a PULL socket from any stream.

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

Create a PULL socket from any stream with custom options.

pub fn try_recv(&mut self) -> Result<Option<Vec<Bytes>>>

Try to receive a message from the already-buffered input without a kernel read.

Returns Ok(None) immediately when the receive buffer is empty. Use after recv() to drain all messages delivered in one kernel read before going back to the event loop. This reduces io_uring submissions for throughput-bound pull loops.

if let Some(first) = pull.recv().await? {
    drop(first);
    while let Some(msg) = pull.try_recv()? {
        drop(msg);
    }
}

pub async fn recv(&mut self) -> Result<Option<Vec<Bytes>>>

Receive a message.

pub async fn recv_into(&mut self, out: &mut Vec<Bytes>) -> Result<bool>

Receive a message into a caller-provided buffer, reusing its allocation.

Like recv but the frames are written into out (cleared first) instead of a freshly allocated Vec. Passing the same out on every call removes the per-message allocation from a steady recv loop, which is the dominant per-message cost for small messages. Returns Ok(true) when a message was read, Ok(false) when the connection closed.

pub fn try_recv_into(&mut self, out: &mut Vec<Bytes>) -> Result<bool>

Try to receive a message into a caller-provided buffer without a kernel read.

The allocation-free counterpart to try_recv: returns Ok(true) with the frames moved into out (reusing its capacity) when a complete message is already buffered, or Ok(false) leaving out untouched when none is. Use it with recv_into to drain a burst from one kernel read without allocating per message.

pub async fn recv_batch(&mut self) -> Result<Option<Vec<Vec<Bytes>>>>

Receive a batch of messages with a single .await.

Blocks until at least one message is available, then drains every further message already decoded from the same kernel read. Returning a burst of small messages from one .await amortizes per-await overhead; it is the receive-side counterpart to PushSocket::send_batch.

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 PullSocket<UnixStream>

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

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

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

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