use std::time::Duration;
use tracing::warn;
use super::replication_logging::{LOG_COMPONENT_ECSTORE, LOG_SUBSYSTEM_REPLICATION};
pub(crate) const ENV_REPL_HEALTH_CHECK_INTERVAL_MS: &str = "RUSTFS_REPL_HEALTH_CHECK_INTERVAL_MS";
pub(crate) const ENV_REPL_MRF_FLUSH_INTERVAL_MS: &str = "RUSTFS_REPL_MRF_FLUSH_INTERVAL_MS";
pub(crate) const ENV_REPL_RESYNC_POLL_MAX_MS: &str = "RUSTFS_REPL_RESYNC_POLL_MAX_MS";
const DEFAULT_HEALTH_CHECK_INTERVAL: Duration = Duration::from_millis(5_000);
const DEFAULT_MRF_FLUSH_INTERVAL: Duration = Duration::from_millis(10_000);
const DEFAULT_RESYNC_POLL_MAX: Duration = Duration::from_millis(60_000);
pub(crate) const MIN_INTERVAL: Duration = Duration::from_millis(10);
pub(crate) fn health_check_interval() -> Duration {
env_interval(ENV_REPL_HEALTH_CHECK_INTERVAL_MS, DEFAULT_HEALTH_CHECK_INTERVAL)
}
pub(crate) fn mrf_flush_interval() -> Duration {
env_interval(ENV_REPL_MRF_FLUSH_INTERVAL_MS, DEFAULT_MRF_FLUSH_INTERVAL)
}
pub(crate) fn resync_poll_max_sleep() -> Duration {
env_interval(ENV_REPL_RESYNC_POLL_MAX_MS, DEFAULT_RESYNC_POLL_MAX)
}
fn env_interval(name: &str, default: Duration) -> Duration {
let raw = match std::env::var(name) {
Ok(raw) => raw,
Err(std::env::VarError::NotPresent) => return default,
Err(std::env::VarError::NotUnicode(_)) => {
warn!(
component = LOG_COMPONENT_ECSTORE,
subsystem = LOG_SUBSYSTEM_REPLICATION,
env = name,
default_ms = default.as_millis() as u64,
"replication timing override is not valid unicode — falling back to default"
);
return default;
}
};
match raw.trim().parse::<u64>() {
Ok(ms) => {
let value = Duration::from_millis(ms);
if value < MIN_INTERVAL {
warn!(
component = LOG_COMPONENT_ECSTORE,
subsystem = LOG_SUBSYSTEM_REPLICATION,
env = name,
value_ms = ms,
min_ms = MIN_INTERVAL.as_millis() as u64,
"replication timing override below minimum — clamping to avoid busy-spin"
);
MIN_INTERVAL
} else {
value
}
}
Err(_) => {
warn!(
component = LOG_COMPONENT_ECSTORE,
subsystem = LOG_SUBSYSTEM_REPLICATION,
env = name,
value = %raw,
default_ms = default.as_millis() as u64,
"invalid replication timing override — falling back to default"
);
default
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use serial_test::serial;
use std::env;
#[allow(unsafe_code)]
fn with_env<F: FnOnce()>(name: &str, value: Option<&str>, test_fn: F) {
let original = env::var_os(name);
match value {
Some(value) => unsafe { env::set_var(name, value) },
None => unsafe { env::remove_var(name) },
}
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(test_fn));
match original {
Some(value) => unsafe { env::set_var(name, value) },
None => unsafe { env::remove_var(name) },
}
if let Err(e) = result {
std::panic::resume_unwind(e);
}
}
#[test]
fn env_var_names_are_a_cross_process_contract() {
assert_eq!(ENV_REPL_HEALTH_CHECK_INTERVAL_MS, "RUSTFS_REPL_HEALTH_CHECK_INTERVAL_MS");
assert_eq!(ENV_REPL_MRF_FLUSH_INTERVAL_MS, "RUSTFS_REPL_MRF_FLUSH_INTERVAL_MS");
assert_eq!(ENV_REPL_RESYNC_POLL_MAX_MS, "RUSTFS_REPL_RESYNC_POLL_MAX_MS");
}
#[test]
#[serial]
fn unset_env_uses_default() {
with_env(ENV_REPL_HEALTH_CHECK_INTERVAL_MS, None, || {
assert_eq!(health_check_interval(), Duration::from_secs(5));
});
with_env(ENV_REPL_MRF_FLUSH_INTERVAL_MS, None, || {
assert_eq!(mrf_flush_interval(), Duration::from_secs(10));
});
with_env(ENV_REPL_RESYNC_POLL_MAX_MS, None, || {
assert_eq!(resync_poll_max_sleep(), Duration::from_secs(60));
});
}
#[test]
#[serial]
fn valid_override_is_applied() {
with_env(ENV_REPL_HEALTH_CHECK_INTERVAL_MS, Some("250"), || {
assert_eq!(health_check_interval(), Duration::from_millis(250));
});
with_env(ENV_REPL_MRF_FLUSH_INTERVAL_MS, Some("100"), || {
assert_eq!(mrf_flush_interval(), Duration::from_millis(100));
});
with_env(ENV_REPL_RESYNC_POLL_MAX_MS, Some("500"), || {
assert_eq!(resync_poll_max_sleep(), Duration::from_millis(500));
});
with_env(ENV_REPL_MRF_FLUSH_INTERVAL_MS, Some(" 750 "), || {
assert_eq!(mrf_flush_interval(), Duration::from_millis(750));
});
}
#[test]
#[serial]
fn invalid_override_falls_back_to_default() {
for bad in ["abc", "", "-5", "1.5", "10s", "99999999999999999999999999"] {
with_env(ENV_REPL_HEALTH_CHECK_INTERVAL_MS, Some(bad), || {
assert_eq!(health_check_interval(), Duration::from_secs(5), "input {bad:?}");
});
with_env(ENV_REPL_MRF_FLUSH_INTERVAL_MS, Some(bad), || {
assert_eq!(mrf_flush_interval(), Duration::from_secs(10), "input {bad:?}");
});
with_env(ENV_REPL_RESYNC_POLL_MAX_MS, Some(bad), || {
assert_eq!(resync_poll_max_sleep(), Duration::from_secs(60), "input {bad:?}");
});
}
}
#[test]
#[serial]
fn zero_or_tiny_override_is_clamped_to_minimum() {
for tiny in ["0", "1", "9"] {
with_env(ENV_REPL_HEALTH_CHECK_INTERVAL_MS, Some(tiny), || {
assert_eq!(health_check_interval(), MIN_INTERVAL, "input {tiny:?}");
});
with_env(ENV_REPL_MRF_FLUSH_INTERVAL_MS, Some(tiny), || {
assert_eq!(mrf_flush_interval(), MIN_INTERVAL, "input {tiny:?}");
});
with_env(ENV_REPL_RESYNC_POLL_MAX_MS, Some(tiny), || {
assert_eq!(resync_poll_max_sleep(), MIN_INTERVAL, "input {tiny:?}");
});
}
with_env(ENV_REPL_HEALTH_CHECK_INTERVAL_MS, Some("10"), || {
assert_eq!(health_check_interval(), MIN_INTERVAL);
});
}
}