Struct PushSocket 

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

PUSH socket for distributing messages in a pipeline.

PUSH sockets send messages to connected PULL sockets in a round-robin fashion, providing load balancing for parallel processing.

Implementations

impl<S> PushSocket<S>

where S: AsyncRead + AsyncWrite + Unpin,

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

Create a new PUSH socket from a stream with default buffer configuration.

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

Create a new PUSH socket with custom buffer configuration and socket options.

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

Send a message to a connected PULL socket.

Messages are distributed in a round-robin fashion when multiple PULL sockets are connected (in a multi-connection scenario).

By default each call writes to the kernel immediately (eager mode, one io_uring operation per message). For throughput-bound pipelines, enable write coalescing via SocketOptions::with_write_coalescing and call flush after the last send in each burst. In coalesced mode, bytes may remain in userspace until the 64 KB threshold fills or flush() is called explicitly.

Errors

Returns an error if the socket is poisoned, disconnected, or if the write fails.

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

Send a single-frame message without allocating a one-element Vec.

This is equivalent to send(vec![frame]), but keeps the hot path for single-frame PUSH/PULL pipelines from measuring the caller’s multipart container allocation.

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

Flush any messages still buffered by write coalescing.

Call this after the last send() in a burst when write_coalescing is enabled to ensure all pending data is written to the kernel.

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

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

Encode and send a batch of messages in a single kernel write.

Encodes every message in msgs into the send buffer, then flushes once. This gives the same kernel-call efficiency as write coalescing but with explicit batch boundaries - no threshold check and no flush() required.

Works independently of the write_coalescing option and can be mixed with send() calls freely.

Returns the number of messages sent.

pub async fn close(self) -> Result<()>

Close the socket gracefully by shutting down the underlying stream.

pub const fn options(&self) -> &SocketOptions

Get a reference to the socket options.

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

Get a mutable reference to the socket options.

pub fn set_options(&mut self, options: SocketOptions)

Set socket options (builder-style).

impl PushSocket<TcpStream>

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

Create a new PUSH socket from a TCP stream with TCP_NODELAY enabled.

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

Create a new PUSH socket from a TCP stream with TCP_NODELAY and custom options.

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

Connect to a remote PUSH socket, storing the endpoint for automatic reconnection.

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

Connect with custom options, storing the endpoint for 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 a message with automatic reconnection on network error.

On BrokenPipe / ConnectionReset, write_from_buf() already sets stream = None, so the next loop iteration reconnects automatically.

Respects max_reconnect_attempts - returns NotConnected when exhausted.

Trait Implementations

impl ProxySocket for PushSocket

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

Receive a multipart message from the socket.

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

Send a multipart message to the socket.

fn socket_desc(&self) -> &'static str

Get a description of the socket for logging.

impl<S> Socket for PushSocket<S>

where S: AsyncRead + AsyncWrite + Unpin + 'static,

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

Send a multipart message on the socket.

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

Receive a multipart message from the socket.

fn socket_type(&self) -> SocketType

Get the socket type.

fn has_more(&self) -> bool

Check if socket has more message frames pending.