b453d5d
use std::time::Duration;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RedisMode {
#[default]
Standalone,
Sentinel,
Cluster,
ValkeyStandalone,
}
impl RedisMode {
pub fn parse(value: &str) -> Option<Self> {
if value.eq_ignore_ascii_case("standalone") {
Some(Self::Standalone)
} else if value.eq_ignore_ascii_case("sentinel") {
Some(Self::Sentinel)
} else if value.eq_ignore_ascii_case("cluster") {
Some(Self::Cluster)
} else if value.eq_ignore_ascii_case("valkey_standalone")
|| value.eq_ignore_ascii_case("valkey")
{
Some(Self::ValkeyStandalone)
} else {
None
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct RedisConfig {
pub url: Option<String>,
pub mode: Option<RedisMode>,
pub database: Option<u16>,
pub pool_size: Option<usize>,
pub connection_timeout_secs: Option<u64>,
pub username: Option<String>,
pub password: Option<String>,
}
impl RedisConfig {
pub fn new(url: impl Into<String>) -> Self {
Self {
url: Some(url.into()),
..Self::default()
}
}
pub fn url(&self) -> &str {
self.url.as_deref().unwrap_or("")
}
pub fn mode(&self) -> RedisMode {
self.mode.unwrap_or_default()
}
pub fn pool_size(&self) -> usize {
self.pool_size.unwrap_or(8)
}
pub fn connection_timeout(&self) -> Duration {
Duration::from_secs(self.connection_timeout_secs.unwrap_or(2))
}
pub fn validate(&self) -> Result<&str, String> {
if let Some(size) = self.pool_size {
if size == 0 {
return Err("redis.pool_size must be at least 1".to_string());
}
if size > 128 {
return Err(format!("redis.pool_size must not exceed 128, got {size}"));
}
}
let url = self
.url
.as_deref()
.filter(|s| !s.is_empty())
.ok_or_else(|| "redis.url must be set".to_string())?;
match self.mode() {
RedisMode::Standalone | RedisMode::ValkeyStandalone => {
if !(url.starts_with("redis://") || url.starts_with("rediss://")) {
return Err(format!(
"redis.url must start with redis:// or rediss://, got {url:?}"
));
}
}
RedisMode::Cluster => {
if !(url.starts_with("redis://")
|| url.starts_with("rediss://")
|| url.contains(","))
{
return Err(format!(
"redis cluster url must start with redis:// or rediss://, or list multiple hosts comma-separated, got {url:?}"
));
}
}
RedisMode::Sentinel => {
if !(url.starts_with("redis://") || url.starts_with("rediss://")) {
return Err(format!(
"redis sentinel url must start with redis:// or rediss://, got {url:?}"
));
}
}
}
Ok(url)
}
}