Struct AsyncConnectionConfig

Source

pub struct AsyncConnectionConfig { /* private fields */ }

Available on crate feature aio only.

Expand description

Options for creation of async connection

Implementations§

Source §

impl AsyncConnectionConfig

Source

pub fn new() -> Self

Creates a new instance of the config with all parameters set to default values.

Source

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.

Source

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.

Source

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(())
});

Source

pub fn set_cache_config(self, cache_config: CacheConfig) -> Self

Available on crate feature cache-aio only.

Sets cache config for MultiplexedConnection, check CacheConfig for more details.

Source

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.

Source

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.

Source

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.

Source

pub fn set_write_backpressure_boundary(self, boundary: usize) -> Self

Sets the flush threshold (backpressure boundary) for the outbound write buffer.

The multiplexed connection encodes commands into an in-memory buffer before writing them to the socket. This value controls how many bytes may accumulate in that buffer before the connection flushes to the socket and applies backpressure to newly queued commands.

With a small threshold the buffer flushes frequently and, when commands are produced faster than the socket drains, it repeatedly grows by reallocation. A larger threshold lets the buffer reach a stable capacity and batch larger writes, trading a higher peak memory bound (roughly this many bytes per connection) for fewer reallocations and syscalls. The buffer still grows lazily, so idle connections do not hold this much memory.

When left unset, the connection keeps tokio_util’s default boundary (8 KiB).

Source

pub fn set_credentials_provider(self, provider: P) -> Self
where P: StreamingCredentialsProvider + 'static,

Available on crate feature token-based-authentication only.

Sets a credentials provider for dynamic authentication (e.g., token-based authentication).

This is useful for authentication mechanisms that require periodic credential refresh, such as Microsoft Entra ID (formerly Azure AD).

§Example

use redis::{AsyncConnectionConfig, EntraIdCredentialsProvider, RetryConfig};

let mut provider = EntraIdCredentialsProvider::new_developer_tools()?;
provider.start(RetryConfig::default());

let config = AsyncConnectionConfig::new()
    .set_credentials_provider(provider);