Struct AsyncConnectionConfig 

pub struct AsyncConnectionConfig { /* private fields */ }

Options for creation of async connection

Implementations

impl AsyncConnectionConfig

pub fn new() -> Self

Creates a new instance of the options with nothing set

pub fn set_connection_timeout( self, connection_timeout: Option<Duration>, ) -> Self

Each connection attempt to the server will time out after connection_timeout.

Set None if you don’t want the connection attempt to time out.

pub fn set_response_timeout(self, response_timeout: Option<Duration>) -> Self

The new connection will time out operations after response_timeout has passed.

Set None if you don’t want requests to time out.

pub fn set_push_sender(self, sender: impl AsyncPushSender) -> Self

Sets sender sender for push values.

The sender can be a channel, or an arbitrary function that handles crate::PushInfo values. This will fail client creation if the connection isn’t configured for RESP3 communications via the crate::RedisConnectionInfo::set_protocol function.

Examples

let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let config = AsyncConnectionConfig::new().set_push_sender(tx);

let messages = Arc::new(Mutex::new(Vec::new()));
let config = AsyncConnectionConfig::new().set_push_sender(move |msg|{
    let Ok(mut messages) = messages.lock() else {
        return Err(redis::aio::SendError);
    };
    messages.push(msg);
    Ok(())
});

pub fn set_dns_resolver(self, dns_resolver: impl AsyncDNSResolver) -> Self

Set the DNS resolver for the underlying TCP connection.

The parameter resolver must implement the crate::io::AsyncDNSResolver trait.

pub fn set_pipeline_buffer_size(self, size: usize) -> Self

Sets the buffer size for the internal pipeline channel.

The multiplexed connection uses an internal channel to queue Redis commands before sending them to the server. This setting controls how many commands can be buffered in that channel.

When the buffer is full, callers will asynchronously wait until space becomes available. A larger buffer allows more commands to be queued during bursts of activity, reducing wait time for callers. However, this comes at the cost of increased memory usage.

The default value is 50. Consider increasing this value for high-concurrency scenarios (e.g., web servers handling many simultaneous requests) where buffer contention may increase overall latency and cause upstream timeouts.

Trait Implementations

impl Clone for AsyncConnectionConfig

fn clone(&self) -> AsyncConnectionConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for AsyncConnectionConfig

Available on crate feature aio only.

fn default() -> Self

Returns the “default value” for a type.