redis-server-wrapper 0.1.0

Type-safe wrapper for redis-server and redis-cli with builder pattern APIs
Documentation

redis-server-wrapper

Crates.io docs.rs CI License

Type-safe Rust wrapper for redis-server and redis-cli with builder pattern APIs.

Manage Redis server processes for testing, development, and CI without Docker -- just redis-server and redis-cli on PATH.

Features

  • Single server -- start/stop with builder pattern, auto-cleanup on drop
  • Cluster -- spin up N-master clusters with optional replicas
  • Sentinel -- full sentinel topology (master + replicas + sentinels)
  • Custom binaries -- point to any redis-server/redis-cli path
  • Arbitrary config -- pass any Redis directive via .extra(key, value)

Prerequisites

redis-server and redis-cli must be available on your PATH (or specify custom paths).

Usage

The API is async-first and requires tokio. Enable the blocking feature for synchronous wrappers; see the Blocking API section below.

Single Server

use redis_server_wrapper::RedisServer;

let server = RedisServer::new()
    .port(6400)
    .bind("127.0.0.1")
    .start()
    .await
    .unwrap();

assert!(server.is_alive().await);
// Stopped automatically on drop.

Cluster

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

Sentinel

use redis_server_wrapper::RedisSentinel;

let sentinel = RedisSentinel::builder()
    .master_port(6390)
    .replicas(2)
    .sentinels(3)
    .start()
    .await
    .unwrap();

assert!(sentinel.is_healthy().await);

Blocking API

Enable the blocking feature for synchronous wrappers that require no async runtime:

[dev-dependencies]
redis-server-wrapper = { version = "...", features = ["blocking"] }

The blocking module mirrors the async API. Every operation blocks the calling thread until it completes:

use redis_server_wrapper::blocking::RedisServer;

let server = RedisServer::new()
    .port(6400)
    .bind("127.0.0.1")
    .start()
    .unwrap();

assert!(server.is_alive());
// Stopped automatically on drop.

Cluster and Sentinel work the same way:

use redis_server_wrapper::blocking::{RedisCluster, RedisSentinel};

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

assert!(cluster.is_healthy());

let sentinel = RedisSentinel::builder()
    .master_port(6390)
    .replicas(2)
    .sentinels(3)
    .start()
    .unwrap();

assert!(sentinel.is_healthy());

License

Licensed under either of

at your option.