use crate::error::BaseError;
use std::env;
use std::fmt;
#[derive(Clone, Default)]
#[non_exhaustive]
pub struct EngineConfig {
pub mysql_url: Option<String>,
pub postgres_url: Option<String>,
pub redis_url: Option<String>,
#[cfg(feature = "mysql")]
pub database: yang_db::DatabaseConfig,
#[cfg(all(feature = "postgres", not(feature = "mysql")))]
pub database: yang_db::PgDatabaseConfig,
#[cfg(feature = "postgres")]
pub postgres_database: yang_db::PgDatabaseConfig,
#[cfg(feature = "redis")]
pub redis: yang_db::RedisConfig,
}
impl fmt::Debug for EngineConfig {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut debug = formatter.debug_struct("EngineConfig");
debug.field("mysql_url", &self.mysql_url.as_deref().map(RedactedUrl));
debug.field(
"postgres_url",
&self.postgres_url.as_deref().map(RedactedUrl),
);
debug.field("redis_url", &self.redis_url.as_deref().map(RedactedUrl));
#[cfg(feature = "mysql")]
debug.field("database", &self.database);
#[cfg(all(feature = "postgres", not(feature = "mysql")))]
debug.field("database", &self.database);
#[cfg(feature = "postgres")]
debug.field("postgres_database", &self.postgres_database);
#[cfg(feature = "redis")]
debug.field("redis", &self.redis);
debug.finish()
}
}
struct RedactedUrl<'a>(&'a str);
impl fmt::Debug for RedactedUrl<'_> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "{:?}", redact_connection_url(self.0))
}
}
fn redact_connection_url(raw: &str) -> String {
let Some((scheme, rest)) = raw.split_once("://") else {
return "[REDACTED]".to_string();
};
if !matches!(
scheme.to_ascii_lowercase().as_str(),
"mysql" | "postgres" | "postgresql" | "redis" | "rediss"
) {
return "[REDACTED]".to_string();
}
let rest = rest.split(['#', '?']).next().unwrap_or(rest);
let (authority, path) = match rest.split_once('/') {
Some((authority, path)) => (authority, Some(path)),
None => (rest, None),
};
let ambiguous_userinfo = !authority.contains('@')
&& (path.is_some_and(|path| path.contains('@'))
|| authority.rsplit_once(':').is_some_and(|(_, tail)| {
!tail.is_empty() && !tail.chars().all(|c| c.is_ascii_digit())
}));
if ambiguous_userinfo {
return format!("{scheme}://[REDACTED]");
}
let authority = authority
.rsplit_once('@')
.map_or(authority, |(_, host)| host);
match path {
Some(path) => format!("{scheme}://{authority}/{path}"),
None => format!("{scheme}://{authority}"),
}
}
#[cfg(feature = "mysql")]
type DatabaseConfigType = yang_db::DatabaseConfig;
#[cfg(all(feature = "postgres", not(feature = "mysql")))]
type DatabaseConfigType = yang_db::PgDatabaseConfig;
#[cfg(any(feature = "mysql", feature = "postgres", feature = "redis"))]
fn parse_env<T: std::str::FromStr>(key: &str) -> Result<Option<T>, BaseError>
where
T::Err: std::fmt::Display,
{
match env::var(key) {
Ok(raw) => raw
.trim()
.parse::<T>()
.map(Some)
.map_err(|e| BaseError::ConfigError(format!("环境变量 {key} 解析失败: {e}"))),
Err(env::VarError::NotPresent) => Ok(None),
Err(env::VarError::NotUnicode(_)) => Err(BaseError::ConfigError(format!(
"环境变量 {key} 含非法 UTF-8"
))),
}
}
#[cfg(any(feature = "mysql", feature = "postgres", feature = "redis"))]
fn parse_bool_env(key: &str) -> Result<Option<bool>, BaseError> {
match env::var(key) {
Ok(raw) => match raw.trim().to_ascii_lowercase().as_str() {
"true" | "1" => Ok(Some(true)),
"false" | "0" => Ok(Some(false)),
other => Err(BaseError::ConfigError(format!(
"环境变量 {key} 期望 true/false/1/0,实得 {other:?}"
))),
},
Err(env::VarError::NotPresent) => Ok(None),
Err(env::VarError::NotUnicode(_)) => Err(BaseError::ConfigError(format!(
"环境变量 {key} 含非法 UTF-8"
))),
}
}
#[cfg(any(feature = "mysql", feature = "postgres"))]
fn load_database_config() -> Result<DatabaseConfigType, BaseError> {
let mut cfg = DatabaseConfigType::default();
if let Some(v) = parse_env::<u32>("YANG_DB_MAX_CONNECTIONS")? {
cfg.max_connections = v;
}
if let Some(v) = parse_env::<u32>("YANG_DB_MIN_CONNECTIONS")? {
cfg.min_connections = v;
}
if let Some(v) = parse_env::<u64>("YANG_DB_CONNECT_TIMEOUT")? {
cfg.connect_timeout = v;
}
if let Some(v) = parse_env::<u64>("YANG_DB_IDLE_TIMEOUT")? {
cfg.idle_timeout = v;
}
if let Some(v) = parse_env::<u64>("YANG_DB_MAX_LIFETIME")? {
cfg.max_lifetime = if v == 0 { None } else { Some(v) };
}
if let Some(v) = parse_bool_env("YANG_DB_TEST_BEFORE_ACQUIRE")? {
cfg.test_before_acquire = v;
}
if let Some(v) = parse_bool_env("YANG_DB_ENABLE_LOGGING")? {
cfg.enable_logging = v;
}
Ok(cfg)
}
#[cfg(feature = "postgres")]
fn parse_string_env(key: &str) -> Result<Option<String>, BaseError> {
match env::var(key) {
Ok(raw) => Ok(Some(raw)),
Err(env::VarError::NotPresent) => Ok(None),
Err(env::VarError::NotUnicode(_)) => Err(BaseError::ConfigError(format!(
"环境变量 {key} 含非法 UTF-8"
))),
}
}
#[cfg(feature = "postgres")]
fn parse_ssl_mode(key: &str, raw: &str) -> Result<yang_db::PgSslMode, BaseError> {
use yang_db::PgSslMode;
match raw.trim().to_ascii_lowercase().replace('_', "-").as_str() {
"disable" => Ok(PgSslMode::Disable),
"prefer" => Ok(PgSslMode::Prefer),
"require" => Ok(PgSslMode::Require),
"verify-ca" => Ok(PgSslMode::VerifyCa),
"verify-full" => Ok(PgSslMode::VerifyFull),
other => Err(BaseError::ConfigError(format!(
"环境变量 {key} 取值非法: {other:?}(允许 disable/prefer/require/verify-ca/verify-full)"
))),
}
}
#[cfg(feature = "postgres")]
fn load_postgres_database_config() -> Result<yang_db::PgDatabaseConfig, BaseError> {
let mut cfg = yang_db::PgDatabaseConfig::default();
if let Some(v) = parse_env::<u32>("YANG_DB_MAX_CONNECTIONS")? {
cfg.max_connections = v;
}
if let Some(v) = parse_env::<u32>("YANG_DB_MIN_CONNECTIONS")? {
cfg.min_connections = v;
}
if let Some(v) = parse_env::<u64>("YANG_DB_CONNECT_TIMEOUT")? {
cfg.connect_timeout = v;
}
if let Some(v) = parse_env::<u64>("YANG_DB_IDLE_TIMEOUT")? {
cfg.idle_timeout = v;
}
if let Some(v) = parse_env::<u64>("YANG_DB_MAX_LIFETIME")? {
cfg.max_lifetime = if v == 0 { None } else { Some(v) };
}
if let Some(v) = parse_bool_env("YANG_DB_TEST_BEFORE_ACQUIRE")? {
cfg.test_before_acquire = v;
}
if let Some(v) = parse_bool_env("YANG_DB_ENABLE_LOGGING")? {
cfg.enable_logging = v;
}
if let Some(v) = parse_string_env("YANG_PG_SEARCH_PATH")? {
cfg.search_path = Some(v);
}
if let Some(v) = parse_string_env("YANG_PG_APPLICATION_NAME")? {
cfg.application_name = Some(v);
}
if let Some(v) = parse_env::<u64>("YANG_PG_STATEMENT_TIMEOUT_MS")? {
cfg.statement_timeout_ms = Some(v);
}
if let Some(v) = parse_env::<u64>("YANG_PG_LOCK_TIMEOUT_MS")? {
cfg.lock_timeout_ms = Some(v);
}
if let Some(v) = parse_env::<u64>("YANG_PG_IDLE_IN_TRANSACTION_TIMEOUT_MS")? {
cfg.idle_in_transaction_timeout_ms = Some(v);
}
if let Some(v) = parse_string_env("YANG_PG_SSL_MODE")? {
cfg.ssl_mode = Some(parse_ssl_mode("YANG_PG_SSL_MODE", &v)?);
}
if let Some(v) = parse_string_env("YANG_PG_SSL_ROOT_CERT")? {
cfg.ssl_root_cert = Some(v.into());
}
if let Some(v) = parse_string_env("YANG_PG_SSL_CLIENT_CERT")? {
cfg.ssl_client_cert = Some(v.into());
}
if let Some(v) = parse_string_env("YANG_PG_SSL_CLIENT_KEY")? {
cfg.ssl_client_key = Some(v.into());
}
cfg.validate()
.map_err(|error| BaseError::ConfigError(format!("PostgreSQL 配置无效: {error}")))?;
Ok(cfg)
}
impl EngineConfig {
pub fn from_env() -> Result<Self, BaseError> {
let mysql_url = match env::var("YANG_MYSQL_URL") {
Ok(v) => Some(v),
Err(env::VarError::NotPresent) => match env::var("YANG_DATABASE_URL") {
Ok(v) => {
eprintln!(
"[yang-base] 环境变量 YANG_DATABASE_URL 已 deprecated,请改用 YANG_MYSQL_URL"
);
Some(v)
}
Err(env::VarError::NotPresent) => None,
Err(env::VarError::NotUnicode(_)) => {
return Err(BaseError::ConfigError(
"环境变量 YANG_DATABASE_URL 含非法 UTF-8".to_string(),
))
}
},
Err(env::VarError::NotUnicode(_)) => {
return Err(BaseError::ConfigError(
"环境变量 YANG_MYSQL_URL 含非法 UTF-8".to_string(),
))
}
};
let postgres_url = match env::var("YANG_POSTGRES_URL") {
Ok(v) => Some(v),
Err(env::VarError::NotPresent) => None,
Err(env::VarError::NotUnicode(_)) => {
return Err(BaseError::ConfigError(
"环境变量 YANG_POSTGRES_URL 含非法 UTF-8".to_string(),
))
}
};
let redis_url = match env::var("YANG_REDIS_URL") {
Ok(v) => Some(v),
Err(env::VarError::NotPresent) => None,
Err(env::VarError::NotUnicode(_)) => {
return Err(BaseError::ConfigError(
"环境变量 YANG_REDIS_URL 含非法 UTF-8".to_string(),
))
}
};
#[cfg(any(feature = "mysql", feature = "postgres"))]
let database = load_database_config()?;
#[cfg(feature = "postgres")]
let postgres_database = load_postgres_database_config()?;
#[cfg(feature = "redis")]
let redis = {
let mut cfg = yang_db::RedisConfig::default();
if let Some(v) = parse_env::<usize>("YANG_REDIS_MAX_CONNECTIONS")? {
cfg.max_connections = v;
}
if let Some(v) = parse_env::<u64>("YANG_REDIS_CONNECT_TIMEOUT")? {
cfg.connect_timeout = v;
}
if let Some(v) = parse_env::<u64>("YANG_REDIS_WAIT_TIMEOUT")? {
cfg.wait_timeout = v;
}
if let Some(v) = parse_env::<u64>("YANG_REDIS_IDLE_TIMEOUT")? {
cfg.idle_timeout = v;
}
if let Some(v) = parse_env::<u64>("YANG_REDIS_RESPONSE_TIMEOUT_MS")? {
cfg.response_timeout_ms = if v == 0 { None } else { Some(v) };
}
if let Some(v) = parse_env::<u32>("YANG_REDIS_RECONNECT_RETRIES")? {
cfg.reconnect_retries = v;
}
if let Some(v) = parse_env::<u64>("YANG_REDIS_RECONNECT_MAX_DELAY_MS")? {
cfg.reconnect_max_delay_ms = v;
}
if let Some(v) = parse_env::<usize>("YANG_REDIS_PIPELINE_MAX_COMMANDS")? {
cfg.pipeline_max_commands = v;
}
if let Some(v) = parse_bool_env("YANG_REDIS_ENABLE_LOGGING")? {
cfg.enable_logging = v;
}
cfg.validate()
.map_err(|error| BaseError::ConfigError(error.to_string()))?;
cfg
};
Ok(Self {
mysql_url,
postgres_url,
redis_url,
#[cfg(any(feature = "mysql", feature = "postgres"))]
database,
#[cfg(feature = "postgres")]
postgres_database,
#[cfg(feature = "redis")]
redis,
})
}
#[cfg(feature = "redis")]
pub fn redis_config(&self) -> Option<(&str, &yang_db::RedisConfig)> {
self.redis_url.as_deref().map(|url| (url, &self.redis))
}
}
#[cfg(all(test, any(feature = "mysql", feature = "postgres", feature = "redis")))]
mod tests {
use super::*;
#[test]
fn from_env_reads_postgres_url() {
std::env::set_var("YANG_POSTGRES_URL", "postgres://u:p@127.0.0.1:55432/test");
let config = EngineConfig::from_env().expect("合法 PostgreSQL URL 应解析成功");
std::env::remove_var("YANG_POSTGRES_URL");
assert_eq!(
config.postgres_url.as_deref(),
Some("postgres://u:p@127.0.0.1:55432/test")
);
}
#[test]
fn parse_bool_env_accepts_forms() {
std::env::set_var("YANG_TEST_BOOL_X", "TRUE");
assert_eq!(parse_bool_env("YANG_TEST_BOOL_X").unwrap(), Some(true));
std::env::set_var("YANG_TEST_BOOL_X", "0");
assert_eq!(parse_bool_env("YANG_TEST_BOOL_X").unwrap(), Some(false));
std::env::set_var("YANG_TEST_BOOL_X", "maybe");
assert!(parse_bool_env("YANG_TEST_BOOL_X").is_err());
std::env::remove_var("YANG_TEST_BOOL_X");
assert_eq!(parse_bool_env("YANG_TEST_BOOL_X").unwrap(), None);
}
#[test]
fn parse_env_rejects_bad_number() {
std::env::set_var("YANG_TEST_NUM_X", "not_a_number");
let r = parse_env::<u32>("YANG_TEST_NUM_X");
assert!(matches!(r, Err(BaseError::ConfigError(_))));
std::env::remove_var("YANG_TEST_NUM_X");
assert_eq!(parse_env::<u32>("YANG_TEST_NUM_X").unwrap(), None);
}
#[cfg(feature = "postgres")]
#[test]
fn from_env_maps_postgres_session_settings() {
std::env::set_var("YANG_PG_SEARCH_PATH", "app,public");
std::env::set_var("YANG_PG_APPLICATION_NAME", "yang-wave3");
std::env::set_var("YANG_PG_STATEMENT_TIMEOUT_MS", "1500");
std::env::set_var("YANG_PG_LOCK_TIMEOUT_MS", "2500");
std::env::set_var("YANG_PG_SSL_MODE", "require");
let config = EngineConfig::from_env().expect("合法 PostgreSQL 会话配置应解析成功");
std::env::remove_var("YANG_PG_SEARCH_PATH");
std::env::remove_var("YANG_PG_APPLICATION_NAME");
std::env::remove_var("YANG_PG_STATEMENT_TIMEOUT_MS");
std::env::remove_var("YANG_PG_LOCK_TIMEOUT_MS");
std::env::remove_var("YANG_PG_SSL_MODE");
let pg = &config.postgres_database;
assert_eq!(pg.search_path.as_deref(), Some("app,public"));
assert_eq!(pg.application_name.as_deref(), Some("yang-wave3"));
assert_eq!(pg.statement_timeout_ms, Some(1500));
assert_eq!(pg.lock_timeout_ms, Some(2500));
assert_eq!(pg.ssl_mode, Some(yang_db::PgSslMode::Require));
}
#[cfg(feature = "postgres")]
#[test]
fn parse_ssl_mode_rejects_unknown_value() {
let error =
parse_ssl_mode("YANG_PG_SSL_MODE", "sometimes").expect_err("未知 SSL 模式应被拒绝");
let message = error.to_string();
assert!(message.contains("YANG_PG_SSL_MODE"), "实得: {message}");
assert!(message.contains("sometimes"), "实得: {message}");
}
#[test]
fn engine_config_debug_redacts_connection_credentials() {
let config = EngineConfig {
mysql_url: Some(
"mysql://mysql-user:mysql-pass@mysql.example.test:3306/app?ssl-mode=required"
.to_string(),
),
postgres_url: Some(
"postgres://pg-user:pg-pass@pg.example.test:5432/app#fragment".to_string(),
),
redis_url: Some("rediss://redis-user:redis-pass@redis.example.test:6379/0".to_string()),
..EngineConfig::default()
};
let debug = format!("{config:?}");
for secret in [
"mysql-user",
"mysql-pass",
"pg-user",
"pg-pass",
"redis-user",
"redis-pass",
"ssl-mode=required",
"fragment",
] {
assert!(
!debug.contains(secret),
"EngineConfig Debug 泄露 {secret}: {debug}"
);
}
assert!(debug.contains("mysql.example.test:3306/app"), "{debug}");
assert!(debug.contains("pg.example.test:5432/app"), "{debug}");
assert!(
debug.contains("rediss://redis.example.test:6379/0"),
"{debug}"
);
assert_eq!(
config.mysql_url.as_deref(),
Some("mysql://mysql-user:mysql-pass@mysql.example.test:3306/app?ssl-mode=required")
);
}
#[test]
fn redact_connection_url_handles_schemes_and_invalid_input() {
assert_eq!(
redact_connection_url("mysql://u:p@host:3306/db?x=1#frag"),
"mysql://host:3306/db"
);
assert_eq!(
redact_connection_url("postgresql://u:p@host/db"),
"postgresql://host/db"
);
assert_eq!(
redact_connection_url("redis://:p@host:6379/0"),
"redis://host:6379/0"
);
assert_eq!(redact_connection_url("rediss://host/0"), "rediss://host/0");
assert_eq!(redact_connection_url("not a url"), "[REDACTED]");
assert_eq!(redact_connection_url("ftp://u:p@host/db"), "[REDACTED]");
assert_eq!(
redact_connection_url("mysql://user:pa/ss@host/db"),
"mysql://[REDACTED]"
);
assert_eq!(
redact_connection_url("mysql://user:pa?ss@host/db"),
"mysql://[REDACTED]"
);
}
}