use std::fmt;
use std::time::Duration;
use rskit_util::SecretString;
use serde::{Deserialize, Serialize};
#[derive(Clone, Deserialize, Serialize)]
pub struct Config {
#[serde(default = "default_host")]
pub host: String,
#[serde(default = "default_port")]
pub port: u16,
pub password: Option<SecretString>,
#[serde(default)]
pub database: u8,
#[serde(default = "default_connect_timeout", with = "duration_seconds")]
pub connect_timeout: Duration,
pub key_prefix: Option<String>,
}
impl fmt::Debug for Config {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Config")
.field("host", &self.host)
.field("port", &self.port)
.field("password", &self.password.as_ref().map(|_| "<redacted>"))
.field("database", &self.database)
.field("connect_timeout", &self.connect_timeout)
.field("key_prefix", &self.key_prefix)
.finish()
}
}
impl Default for Config {
fn default() -> Self {
Self {
host: default_host(),
port: default_port(),
password: None,
database: 0,
connect_timeout: default_connect_timeout(),
key_prefix: None,
}
}
}
impl Config {
pub(crate) fn connection_url(&self) -> String {
match &self.password {
Some(pw) => format!(
"redis://:{}@{}:{}/{}",
pw.expose(),
self.host,
self.port,
self.database
),
None => format!("redis://{}:{}/{}", self.host, self.port, self.database),
}
}
}
fn default_host() -> String {
"127.0.0.1".to_owned()
}
fn default_port() -> u16 {
6379
}
fn default_connect_timeout() -> Duration {
Duration::from_secs(5)
}
mod duration_seconds {
use std::time::Duration;
use serde::{Deserialize, Deserializer, Serializer};
pub fn deserialize<'de, D>(deserializer: D) -> Result<Duration, D::Error>
where
D: Deserializer<'de>,
{
u64::deserialize(deserializer).map(Duration::from_secs)
}
pub fn serialize<S>(duration: &Duration, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_u64(duration.as_secs())
}
}