Struct Client 

pub struct Client<PR> { /* private fields */ }

Implementations

impl<PR> Client<PR>

where PR: RequestProcessor + Sync + 'static,

pub async fn send_read( &mut self, request: RemotingCommand, timeout_millis: u64, ) -> RocketMQResult<RemotingCommand>

Invokes a remote operation with the given RemotingCommand.

Arguments

• request - The RemotingCommand representing the request.

Returns

The RemotingCommand representing the response, wrapped in a Result. Returns an error if the invocation fails.

pub async fn invoke_with_callback<F>(&self, _request: RemotingCommand, _func: F)

where F: FnMut(),

Invokes a remote operation with the given RemotingCommand and provides a callback function for handling the response.

Arguments

• _request - The RemotingCommand representing the request.
• _func - The callback function to handle the response.

This method is a placeholder and currently does not perform any functionality.

pub async fn send(&mut self, request: RemotingCommand) -> RocketMQResult<()>

Sends a request to the remote remoting_server.

Arguments

• request - The RemotingCommand representing the request.

Returns

A Result indicating success or failure in sending the request.

pub async fn send_batch( &mut self, requests: Vec<RemotingCommand>, ) -> RocketMQResult<()>

Sends multiple requests in a batch (fire-and-forget, no response expected).

Performance

Batching provides 2-4x throughput improvement for small messages:

• Single system call instead of N
• Better CPU cache locality during encoding
• Reduced Nagle algorithm delays

Use Cases

• Log shipping (async, high volume)
• Metrics reporting
• Event publishing

Arguments

• requests - Vector of commands to send (consumed)

Returns

• Ok(()): All commands queued successfully
• Err(e): Channel send error (client shutdown)

Example

let commands = vec![
    RemotingCommand::create_request_command(/*...*/),
    RemotingCommand::create_request_command(/*...*/),
];
client.send_batch(commands).await?;

pub async fn send_batch_read( &mut self, requests: Vec<RemotingCommand>, timeout_millis: u64, ) -> RocketMQResult<Vec<RocketMQResult<RemotingCommand>>>

Sends multiple requests and collects responses (request-response batch).

Performance vs send_read()

100x send_read():    ~5000ms  (sequential network RTT)
send_batch_read():   ~100ms   (parallel + single RTT)
Improvement: 50x faster

Arguments

• requests - Vector of commands expecting responses
• timeout_millis - Timeout for each individual request

Returns

Vector of results in the same order as input requests

Example

let requests = vec![cmd1, cmd2, cmd3];
let responses = client.send_batch_read(requests, 3000).await?;
for response in responses {
    match response {
        Ok(cmd) => println!("Success: {:?}", cmd),
        Err(e) => eprintln!("Failed: {}", e),
    }
}

pub fn connection(&self) -> &Connection

pub fn connection_mut(&mut self) -> &mut Connection

Trait Implementations

impl<PR: Clone> Clone for Client<PR>

fn clone(&self) -> Client<PR>

Returns a duplicate of the value.

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

Performs copy-assignment from source.