Struct RedisClusterBuilder 

pub struct RedisClusterBuilder { /* private fields */ }

Builder for a Redis Cluster.

Example

use redis_server_wrapper::RedisCluster;

let cluster = RedisCluster::builder()
    .masters(3)
    .replicas_per_master(1)
    .base_port(7000)
    .start()
    .await
    .unwrap();

assert!(cluster.is_healthy().await);
// Stopped automatically on Drop.

Implementations

impl RedisClusterBuilder

pub fn masters(self, n: u16) -> Self

Set the number of master nodes (default: 3).

pub fn replicas_per_master(self, n: u16) -> Self

Set the number of replicas per master (default: 0).

pub fn base_port(self, port: u16) -> Self

Set the base port for cluster nodes (default: 7000).

Nodes are assigned consecutive ports starting at this value.

pub fn bind(self, bind: impl Into<String>) -> Self

Set the bind address for all cluster nodes (default: "127.0.0.1").

pub fn password(self, password: impl Into<String>) -> Self

Set a requirepass password for all cluster nodes.

pub fn logfile(self, path: impl Into<String>) -> Self

Set the log file path for all cluster nodes.

pub fn save(self, save: bool) -> Self

Set the RDB save policy for all cluster nodes.

true omits the save directive (Redis defaults apply). false emits save "" to disable RDB entirely.

pub fn save_schedule(self, schedule: Vec<(u64, u64)>) -> Self

Set a custom RDB save schedule for all cluster nodes.

pub fn appendonly(self, appendonly: bool) -> Self

Enable or disable AOF persistence for all cluster nodes.

pub fn cluster_node_timeout(self, ms: u64) -> Self

Set the cluster node timeout in milliseconds for all nodes (default: 5000).

pub fn cluster_require_full_coverage(self, require: bool) -> Self

Require full hash slot coverage for the cluster to accept writes.

pub fn cluster_allow_reads_when_down(self, allow: bool) -> Self

Allow reads when the cluster is down.

pub fn cluster_allow_pubsubshard_when_down(self, allow: bool) -> Self

Allow pubsub shard channels when the cluster is down.

pub fn cluster_allow_replica_migration(self, allow: bool) -> Self

Allow automatic replica migration between masters.

pub fn cluster_migration_barrier(self, barrier: u32) -> Self

Set the minimum number of replicas a master must retain before one can migrate.

pub fn cluster_announce_hostname(self, hostname: impl Into<String>) -> Self

Set the hostname each node announces to the cluster.

pub fn cluster_preferred_endpoint_type( self, endpoint_type: impl Into<String>, ) -> Self

Set the preferred endpoint type for cluster redirections (e.g. "ip", "hostname").

pub fn cluster_replica_no_failover(self, no_failover: bool) -> Self

Prevent replicas from attempting automatic failover.

Manual failover via CLUSTER FAILOVER still works.

pub fn cluster_replica_validity_factor(self, factor: u32) -> Self

Set the replica validity factor for failover eligibility.

A replica will not failover if it has been disconnected from the master for more than (node-timeout * factor) + repl-ping-replica-period seconds. Set to 0 to allow any replica to failover regardless of staleness.

pub fn cluster_announce_ip(self, ip: impl Into<String>) -> Self

Set the IP address nodes announce for client redirects (MOVED/ASKING).

pub fn cluster_announce_port(self, port: u16) -> Self

Set the client port nodes announce for redirects.

pub fn cluster_announce_bus_port(self, port: u16) -> Self

Set the cluster bus port nodes announce for gossip.

pub fn cluster_announce_tls_port(self, port: u16) -> Self

Set the TLS client port nodes announce for redirects.

pub fn cluster_announce_human_nodename(self, name: impl Into<String>) -> Self

Set a friendly node name broadcast for debugging/admin display.

pub fn cluster_port(self, port: u16) -> Self

Set a dedicated cluster bus port (default: client port + 10000).

pub fn cluster_link_sendbuf_limit(self, limit: u64) -> Self

Set the maximum memory for a cluster bus link’s output buffer.

When exceeded, the link is disconnected. Set to 0 for unlimited.

pub fn cluster_compatibility_sample_ratio(self, ratio: u32) -> Self

Set the cluster compatibility sample ratio.

pub fn cluster_slot_migration_handoff_max_lag_bytes(self, bytes: u64) -> Self

Set the maximum replication lag in bytes before slot migration handoff.

pub fn cluster_slot_migration_write_pause_timeout(self, ms: u64) -> Self

Set the write pause timeout in milliseconds during slot migration.

pub fn cluster_slot_stats_enabled(self, enable: bool) -> Self

Enable per-slot statistics tracking.

pub fn min_replicas_to_write(self, n: u32) -> Self

Set the minimum number of connected replicas before the master accepts writes.

Useful for split-brain protection: a partitioned master with no reachable replicas stops accepting writes, reducing data loss during partitions.

pub fn min_replicas_max_lag(self, seconds: u32) -> Self

Set the maximum replication lag (seconds) before a replica is considered disconnected.

Used with min_replicas_to_write to determine if enough replicas are connected.

pub fn repl_diskless_sync(self, enable: bool) -> Self

Enable or disable diskless replication sync.

Diskless sync is faster but uses more memory during transfer.

pub fn repl_diskless_sync_delay(self, seconds: u32) -> Self

Set the delay in seconds before starting a diskless replication transfer.

Allows batching multiple replicas syncing at once.

pub fn repl_ping_replica_period(self, seconds: u32) -> Self

Set how often replicas ping the master (seconds).

Used in the replica validity calculation: (node-timeout * validity-factor) + repl-ping-replica-period.

pub fn repl_timeout(self, seconds: u32) -> Self

Set the replication timeout in seconds.

If a replica doesn’t hear from master for this long, it considers the link dead.

pub fn with_node_config( self, f: impl FnMut(NodeContext) -> RedisServer + Send + 'static, ) -> Self

Set a per-node configuration callback.

The callback receives a NodeContext containing the pre-configured RedisServer builder (with all uniform settings already applied) and metadata about the node’s position in the cluster. It must return the (possibly modified) RedisServer builder.

Example

use redis_server_wrapper::RedisCluster;

let cluster = RedisCluster::builder()
    .masters(3)
    .replicas_per_master(1)
    .base_port(7000)
    .with_node_config(|ctx| {
        let is_replica = ctx.is_replica();
        let index = ctx.index;
        let mut server = ctx.server;
        if is_replica {
            server = server.cluster_replica_no_failover(true);
        }
        if index == 0 {
            server = server.maxmemory("512mb");
        }
        server
    })
    .start()
    .await
    .unwrap();

pub fn extra(self, key: impl Into<String>, value: impl Into<String>) -> Self

Set an arbitrary config directive for all cluster nodes.

pub fn redis_server_bin(self, bin: impl Into<String>) -> Self

Set a custom redis-server binary path.

pub fn redis_cli_bin(self, bin: impl Into<String>) -> Self

Set a custom redis-cli binary path.

pub async fn start(self) -> Result<RedisClusterHandle>

Start all nodes and form the cluster.