use crate::config::settings::Settings;
use anyhow::Result;
use confers::{ConfigBuilder, EnvSource};
use log::{error, info};
use sdforge::validator::Validate;
pub fn load_settings() -> Result<Settings> {
let settings = ConfigBuilder::<Settings>::new()
.file("config/default.toml")
.source(Box::new(
EnvSource::with_prefix("CRAWLRS__").separator("__"),
))
.build()
.map_err(|e| anyhow::anyhow!("Configuration load failed: {}", e))?;
settings
.validate()
.map_err(|e| anyhow::anyhow!("Configuration validation failed: {}", e))?;
settings.concurrency.validate();
crate::config::validation::validate_values(&settings)
.map_err(|e| anyhow::anyhow!("Configuration values validation failed: {}", e))?;
settings
.cache
.validate_backend()
.map_err(|e| anyhow::anyhow!("Configuration validation failed: {}", e))?;
crate::config::settings::validate_i18n(&settings.i18n)
.map_err(|e| anyhow::anyhow!("Configuration validation failed: {}", e))?;
info!("Configuration loaded and validated successfully from config sources");
Ok(settings)
}
pub fn detect_available_port(settings: &mut Settings) -> Result<u16> {
let port_result = crate::utils::port_sniffer::PortSniffer::find_available_port(
settings.server.port,
settings.server.enable_port_detection,
50,
);
match port_result {
Ok(result) => {
if result.port != settings.server.port {
info!(
"Default port {} is occupied, switching to port {}",
settings.server.port, result.port
);
settings.server.port = result.port;
}
for log in result.logs {
info!("{}", log);
}
Ok(result.port)
}
Err(e) => {
error!("Port detection failed: {}", e);
Err(anyhow::anyhow!("Failed to find available port: {}", e))
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_load_settings_returns_valid_config() {
let settings = load_settings();
assert!(
settings.is_ok(),
"load_settings failed: {:?}",
settings.err()
);
let settings = settings.unwrap();
assert_eq!(settings.server.port, 8899);
assert_eq!(settings.server.host, "0.0.0.0");
}
#[test]
fn test_load_settings_has_database_config() {
let settings = load_settings().expect("Failed to load settings");
let _max_conn = &settings.database.max_connections;
}
#[test]
fn test_load_settings_has_rate_limiting_config() {
let settings = load_settings().expect("Failed to load settings");
let _enabled = settings.rate_limiting.enabled;
let _rpm = settings.rate_limiting.default_rpm;
}
#[test]
fn test_load_settings_has_cors_config() {
let settings = load_settings().expect("Failed to load settings");
assert_eq!(settings.cors.allowed_origins, "*");
}
#[test]
fn test_load_settings_has_tls_fingerprint_engine_config() {
let settings = load_settings().expect("Failed to load settings");
assert!(!settings.engines.tls_fingerprint.enabled);
assert_eq!(settings.engines.tls_fingerprint.timeout_seconds, 15);
}
#[test]
fn test_load_settings_returns_consistent_port() {
let settings1 = load_settings().expect("Failed to load settings");
let settings2 = load_settings().expect("Failed to load settings");
assert_eq!(settings1.server.port, settings2.server.port);
}
#[test]
fn test_load_settings_has_content_extraction_config() {
let settings = load_settings().expect("Failed to load settings");
assert_eq!(settings.content_extraction.min_word_count, 150);
assert!((settings.content_extraction.replacement_length_ratio - 1.5).abs() < f64::EPSILON);
assert!((settings.content_extraction.prose_min_sentence_words - 7.0).abs() < f64::EPSILON);
assert!((settings.content_extraction.prose_max_link_density - 0.7).abs() < f64::EPSILON);
}
#[test]
fn test_load_settings_has_llm_chunking_config() {
let settings = load_settings().expect("Failed to load settings");
let chunking = &settings.llm.chunking;
assert!(!chunking.enabled, "默认关:长文单 prompt 直发(现状)");
assert_eq!(chunking.model_context_tokens, 8192);
assert_eq!(chunking.max_output_tokens, 2048);
assert_eq!(chunking.prompt_overhead_tokens, 1024);
assert!((chunking.chars_per_token - 4.0).abs() < f64::EPSILON);
assert_eq!(chunking.max_parallel, 4);
assert!(chunking.merge_enabled);
assert!(chunking.term_precheck_enabled);
}
#[test]
fn test_load_settings_returns_consistent_host() {
let settings1 = load_settings().expect("Failed to load settings");
let settings2 = load_settings().expect("Failed to load settings");
assert_eq!(settings1.server.host, settings2.server.host);
}
#[test]
fn test_load_settings_server_enable_port_detection_exists() {
let settings = load_settings().expect("Failed to load settings");
let _ = settings.server.enable_port_detection;
}
#[test]
fn test_load_settings_has_server_config() {
let settings = load_settings().expect("Failed to load settings");
assert!(!settings.server.host.is_empty());
assert!(settings.server.port > 0);
}
#[test]
fn test_detect_available_port_with_detection_disabled_returns_ok() {
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = 0; settings.server.enable_port_detection = false;
settings.server.port = 49999;
let result = detect_available_port(&mut settings);
assert!(
result.is_ok(),
"detect_available_port should return Ok for a free high port with detection disabled"
);
}
#[test]
fn test_detect_available_port_returns_configured_port_when_free() {
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = 49998;
settings.server.enable_port_detection = false;
let port = detect_available_port(&mut settings).expect("Should find available port");
assert_eq!(
port, 49998,
"Should return the configured port when it is free"
);
}
#[test]
fn test_detect_available_port_updates_settings_port() {
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = 49997;
settings.server.enable_port_detection = false;
let _ = detect_available_port(&mut settings).expect("Should find available port");
assert_eq!(
settings.server.port, 49997,
"settings.server.port should match the detected port"
);
}
#[test]
fn test_detect_available_port_with_detection_enabled_returns_ok() {
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = 49996;
settings.server.enable_port_detection = true;
let result = detect_available_port(&mut settings);
assert!(
result.is_ok(),
"detect_available_port should return Ok with detection enabled"
);
}
#[test]
fn test_detect_available_port_does_not_change_when_port_free() {
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = 49995;
settings.server.enable_port_detection = false;
let original_port = settings.server.port;
let _ = detect_available_port(&mut settings).expect("Should find available port");
assert_eq!(
settings.server.port, original_port,
"Port should not change when the configured port is free"
);
}
#[test]
fn test_detect_available_port_with_detection_enabled_finds_port() {
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = 49994;
settings.server.enable_port_detection = true;
let result = detect_available_port(&mut settings);
assert!(
result.is_ok(),
"detect_available_port with detection enabled should find a port"
);
let port = result.unwrap();
assert!(port > 0, "Detected port should be greater than 0");
}
use crate::test_utils::ensure_debug_logger;
#[test]
fn test_detect_available_port_switches_when_configured_port_occupied() {
ensure_debug_logger();
let listener = std::net::TcpListener::bind("0.0.0.0:0").expect("Failed to bind listener");
let occupied_port = listener.local_addr().unwrap().port();
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = occupied_port;
settings.server.enable_port_detection = true;
let result = detect_available_port(&mut settings);
assert!(
result.is_ok(),
"detect_available_port should succeed by switching ports"
);
let detected_port = result.unwrap();
assert_ne!(
detected_port, occupied_port,
"detected port should differ from occupied configured port"
);
assert_eq!(
settings.server.port, detected_port,
"settings.server.port should be updated to the detected port"
);
drop(listener);
}
#[test]
fn test_detect_available_port_error_at_65535_boundary() {
ensure_debug_logger();
let _listener = std::net::TcpListener::bind("0.0.0.0:65535").ok();
let mut settings = load_settings().expect("Failed to load settings");
settings.server.port = 65535;
settings.server.enable_port_detection = true;
let result = detect_available_port(&mut settings);
assert!(
result.is_err(),
"detect_available_port should return error when 65535 is occupied"
);
let err_msg = result.unwrap_err().to_string();
assert!(
err_msg.contains("Failed to find available port"),
"error should mention port detection failure, got: {}",
err_msg
);
}
}