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 config with all parameters set to default values.

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.

pub fn set_concurrency_limit(self, limit: usize) -> Self

Sets the maximum number of concurrent in-flight requests on this connection.

When set, at most limit requests can be awaiting a response at any given time. Additional requests will wait until an in-flight request completes.

Pipelined commands try to acquire one permit per command, but will proceed with fewer if not all are immediately available. This means a pipeline may temporarily push the effective in-flight count above the limit.

This is useful for preventing a large backlog of commands from building up when the server becomes slow or unresponsive. Without a limit, requests continue to queue unboundedly. When the server is degraded, requests near the back of the queue spend most of their time waiting behind earlier requests and are likely to hit their response timeout before the server even processes them – wasting work on both sides. Setting a concurrency limit caps the number of in-flight requests, so backpressure is applied earlier and fewer requests are lost to timeouts.

By default there is no limit.

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.