Gurty -> usable state

protocol/cli/src/config.rs

@@ -0,0 +1,607 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GurtConfig {
+    pub server: ServerConfig,
+    pub tls: Option<TlsConfig>,
+    pub logging: Option<LoggingConfig>,
+    pub security: Option<SecurityConfig>,
+    pub error_pages: Option<ErrorPagesConfig>,
+    pub headers: Option<HashMap<String, String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ServerConfig {
+    #[serde(default = "default_host")]
+    pub host: String,
+    
+    #[serde(default = "default_port")]
+    pub port: u16,
+    
+    #[serde(default = "default_protocol_version")]
+    pub protocol_version: String,
+    
+    #[serde(default = "default_alpn_identifier")]
+    pub alpn_identifier: String,
+    
+    pub timeouts: Option<TimeoutsConfig>,
+    
+    #[serde(default = "default_max_connections")]
+    pub max_connections: u32,
+    
+    #[serde(default = "default_max_message_size")]
+    pub max_message_size: String,
+    
+    #[serde(skip)]
+    pub base_directory: Arc<PathBuf>,
+    
+    #[serde(skip)]
+    pub verbose: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TimeoutsConfig {
+    #[serde(default = "default_handshake_timeout")]
+    pub handshake: u64,
+    
+    #[serde(default = "default_request_timeout")]
+    pub request: u64,
+    
+    #[serde(default = "default_connection_timeout")]
+    pub connection: u64,
+    
+    #[serde(default = "default_pool_idle_timeout")]
+    pub pool_idle: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TlsConfig {
+    pub certificate: PathBuf,
+    pub private_key: PathBuf,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LoggingConfig {
+    #[serde(default = "default_log_level")]
+    pub level: String,
+    
+    pub access_log: Option<PathBuf>,
+    pub error_log: Option<PathBuf>,
+    
+    #[serde(default = "default_log_requests")]
+    pub log_requests: bool,
+    
+    #[serde(default)]
+    pub log_responses: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SecurityConfig {
+    #[serde(default)]
+    pub deny_files: Vec<String>,
+    
+    #[serde(default = "default_allowed_methods")]
+    pub allowed_methods: Vec<String>,
+    
+    #[serde(default = "default_rate_limit_requests")]
+    pub rate_limit_requests: u32,
+    
+    #[serde(default = "default_rate_limit_connections")]
+    pub rate_limit_connections: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ErrorPagesConfig {
+    #[serde(flatten)]
+    pub pages: HashMap<String, String>,
+    
+    pub default: Option<ErrorPageDefaults>,
+}
+
+impl ErrorPagesConfig {
+    pub fn get_page(&self, status_code: u16) -> Option<&String> {
+        let code_str = status_code.to_string();
+        self.pages.get(&code_str)
+    }
+    
+    pub fn get_default_page(&self, status_code: u16) -> Option<&String> {
+        if let Some(defaults) = &self.default {
+            let code_str = status_code.to_string();
+            defaults.pages.get(&code_str)
+        } else {
+            None
+        }
+    }
+    
+    pub fn get_any_page(&self, status_code: u16) -> Option<&String> {
+        self.get_page(status_code)
+            .or_else(|| self.get_default_page(status_code))
+    }
+
+    pub fn get_page_content(&self, status_code: u16, base_dir: &std::path::Path) -> Option<String> {
+        if let Some(page_value) = self.get_page(status_code) {
+            if page_value.starts_with('/') || page_value.starts_with("./") {
+                let file_path = if page_value.starts_with('/') {
+                    base_dir.join(&page_value[1..])
+                } else {
+                    base_dir.join(page_value)
+                };
+                
+                if let Ok(content) = std::fs::read_to_string(&file_path) {
+                    return Some(content);
+                } else {
+                    tracing::warn!("Failed to read error page file: {}", file_path.display());
+                    return None;
+                }
+            } else {
+                return Some(page_value.clone());
+            }
+        }
+        
+        if let Some(page_value) = self.get_default_page(status_code) {
+            return Some(page_value.clone());
+        }
+        
+        None
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ErrorPageDefaults {
+    #[serde(flatten)]
+    pub pages: HashMap<String, String>,
+}
+
+fn default_host() -> String { "127.0.0.1".to_string() }
+fn default_port() -> u16 { 4878 }
+fn default_protocol_version() -> String { "1.0.0".to_string() }
+fn default_alpn_identifier() -> String { "GURT/1.0".to_string() }
+fn default_max_connections() -> u32 { 10 }
+fn default_max_message_size() -> String { "10MB".to_string() }
+fn default_handshake_timeout() -> u64 { 5 }
+fn default_request_timeout() -> u64 { 30 }
+fn default_connection_timeout() -> u64 { 10 }
+fn default_pool_idle_timeout() -> u64 { 300 }
+fn default_log_level() -> String { "info".to_string() }
+fn default_log_requests() -> bool { true }
+fn default_allowed_methods() -> Vec<String> {
+    vec!["GET".to_string(), "POST".to_string(), "PUT".to_string(), 
+         "DELETE".to_string(), "HEAD".to_string(), "OPTIONS".to_string(), "PATCH".to_string()]
+}
+fn default_rate_limit_requests() -> u32 { 100 }
+fn default_rate_limit_connections() -> u32 { 10 }
+
+impl Default for GurtConfig {
+    fn default() -> Self {
+        Self {
+            server: ServerConfig::default(),
+            tls: None,
+            logging: None,
+            security: None,
+            error_pages: None,
+            headers: None,
+        }
+    }
+}
+
+impl Default for ServerConfig {
+    fn default() -> Self {
+        Self {
+            host: default_host(),
+            port: default_port(),
+            protocol_version: default_protocol_version(),
+            alpn_identifier: default_alpn_identifier(),
+            timeouts: None,
+            max_connections: default_max_connections(),
+            max_message_size: default_max_message_size(),
+            base_directory: Arc::new(PathBuf::from(".")),
+            verbose: false,
+        }
+    }
+}
+
+impl GurtConfig {
+    pub fn from_file<P: AsRef<std::path::Path>>(path: P) -> crate::Result<Self> {
+        let content = std::fs::read_to_string(path)
+            .map_err(|e| crate::ServerError::InvalidConfiguration(format!("Failed to read config file: {}", e)))?;
+        
+        let config: GurtConfig = toml::from_str(&content)
+            .map_err(|e| crate::ServerError::InvalidConfiguration(format!("Failed to parse config file: {}", e)))?;
+        
+        Ok(config)
+    }
+
+    pub fn builder() -> GurtConfigBuilder {
+        GurtConfigBuilder::default()
+    }
+
+    pub fn address(&self) -> String {
+        format!("{}:{}", self.server.host, self.server.port)
+    }
+
+    pub fn max_message_size_bytes(&self) -> crate::Result<u64> {
+        parse_size(&self.server.max_message_size)
+    }
+
+    pub fn get_handshake_timeout(&self) -> Duration {
+        Duration::from_secs(
+            self.server.timeouts
+                .as_ref()
+                .map(|t| t.handshake)
+                .unwrap_or(default_handshake_timeout())
+        )
+    }
+
+    pub fn get_request_timeout(&self) -> Duration {
+        Duration::from_secs(
+            self.server.timeouts
+                .as_ref()
+                .map(|t| t.request)
+                .unwrap_or(default_request_timeout())
+        )
+    }
+
+    pub fn get_connection_timeout(&self) -> Duration {
+        Duration::from_secs(
+            self.server.timeouts
+                .as_ref()
+                .map(|t| t.connection)
+                .unwrap_or(default_connection_timeout())
+        )
+    }
+
+    pub fn should_deny_file(&self, file_path: &str) -> bool {
+        if let Some(security) = &self.security {
+            for pattern in &security.deny_files {
+                if matches_pattern(file_path, pattern) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    pub fn is_method_allowed(&self, method: &str) -> bool {
+        if let Some(security) = &self.security {
+            security.allowed_methods.contains(&method.to_uppercase())
+        } else {
+            default_allowed_methods().contains(&method.to_uppercase())
+        }
+    }
+
+    pub fn default_with_directory(base_dir: PathBuf) -> Self {
+        let mut config = Self::default();
+        config.server.base_directory = Arc::new(base_dir);
+        config
+    }
+
+    pub fn from_toml(toml_content: &str, base_dir: PathBuf) -> crate::Result<Self> {
+        let mut config: GurtConfig = toml::from_str(toml_content)
+            .map_err(|e| crate::ServerError::InvalidConfiguration(format!("Failed to parse config: {}", e)))?;
+        
+        config.server.base_directory = Arc::new(base_dir);
+        Ok(config)
+    }
+
+    pub fn validate(&self) -> crate::Result<()> {
+        if !self.server.base_directory.exists() || !self.server.base_directory.is_dir() {
+            return Err(crate::ServerError::InvalidConfiguration(
+                format!("Invalid base directory: {}", self.server.base_directory.display())
+            ));
+        }
+
+        if let Some(tls) = &self.tls {
+            if !tls.certificate.exists() {
+                return Err(crate::ServerError::TlsConfiguration(
+                    format!("Certificate file does not exist: {}", tls.certificate.display())
+                ));
+            }
+            if !tls.private_key.exists() {
+                return Err(crate::ServerError::TlsConfiguration(
+                    format!("Private key file does not exist: {}", tls.private_key.display())
+                ));
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Default)]
+pub struct GurtConfigBuilder {
+    config: GurtConfig,
+}
+
+impl GurtConfigBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn host<S: Into<String>>(mut self, host: S) -> Self {
+        self.config.server.host = host.into();
+        self
+    }
+
+    pub fn port(mut self, port: u16) -> Self {
+        self.config.server.port = port;
+        self
+    }
+
+    pub fn base_directory<P: Into<PathBuf>>(mut self, dir: P) -> Self {
+        self.config.server.base_directory = Arc::new(dir.into());
+        self
+    }
+
+    pub fn verbose(mut self, verbose: bool) -> Self {
+        self.config.server.verbose = verbose;
+        self
+    }
+
+    pub fn tls_config(mut self, cert_path: PathBuf, key_path: PathBuf) -> Self {
+        self.config.tls = Some(TlsConfig {
+            certificate: cert_path,
+            private_key: key_path,
+        });
+        self
+    }
+
+    pub fn logging_config(mut self, config: LoggingConfig) -> Self {
+        self.config.logging = Some(config);
+        self
+    }
+
+    pub fn security_config(mut self, config: SecurityConfig) -> Self {
+        self.config.security = Some(config);
+        self
+    }
+
+    pub fn error_pages_config(mut self, config: ErrorPagesConfig) -> Self {
+        self.config.error_pages = Some(config);
+        self
+    }
+
+    pub fn headers(mut self, headers: HashMap<String, String>) -> Self {
+        self.config.headers = Some(headers);
+        self
+    }
+
+    pub fn from_file<P: AsRef<std::path::Path>>(mut self, path: P) -> crate::Result<Self> {
+        let file_config = GurtConfig::from_file(path)?;
+        self.config = merge_configs(file_config, self.config);
+        Ok(self)
+    }
+
+    pub fn merge_cli_args(mut self, cli_args: &crate::cli::ServeCommand) -> Self {
+        self.config.server.host = cli_args.host.clone();
+        self.config.server.port = cli_args.port;
+        self.config.server.base_directory = Arc::new(cli_args.dir.clone());
+        self.config.server.verbose = cli_args.verbose;
+
+        if let (Some(cert), Some(key)) = (&cli_args.cert, &cli_args.key) {
+            self.config.tls = Some(TlsConfig {
+                certificate: cert.clone(),
+                private_key: key.clone(),
+            });
+        }
+
+        self
+    }
+
+    pub fn build(self) -> crate::Result<GurtConfig> {
+        let config = self.config;
+
+        if !config.server.base_directory.exists() || !config.server.base_directory.is_dir() {
+            return Err(crate::ServerError::InvalidConfiguration(
+                format!("Invalid base directory: {}", config.server.base_directory.display())
+            ));
+        }
+
+        if let Some(tls) = &config.tls {
+            if !tls.certificate.exists() {
+                return Err(crate::ServerError::TlsConfiguration(
+                    format!("Certificate file does not exist: {}", tls.certificate.display())
+                ));
+            }
+            if !tls.private_key.exists() {
+                return Err(crate::ServerError::TlsConfiguration(
+                    format!("Private key file does not exist: {}", tls.private_key.display())
+                ));
+            }
+        }
+
+        Ok(config)
+    }
+}
+
+
+fn parse_size(size_str: &str) -> crate::Result<u64> {
+    let size_str = size_str.trim().to_uppercase();
+    
+    if let Some(captures) = regex::Regex::new(r"^(\d+(?:\.\d+)?)\s*([KMGT]?B?)$").unwrap().captures(&size_str) {
+        let number: f64 = captures[1].parse()
+            .map_err(|_| crate::ServerError::InvalidConfiguration(format!("Invalid size format: {}", size_str)))?;
+        
+        let unit = captures.get(2).map_or("", |m| m.as_str());
+        
+        let multiplier: u64 = match unit {
+            "" | "B" => 1,
+            "KB" => 1_000,
+            "MB" => 1_000_000,
+            "GB" => 1_000_000_000,
+            "TB" => 1_000_000_000_000,
+            _ => return Err(crate::ServerError::InvalidConfiguration(format!("Unknown size unit: {}", unit))),
+        };
+        let number = (number * multiplier as f64) as u64;
+        Ok(number)
+    } else {
+        Err(crate::ServerError::InvalidConfiguration(format!("Invalid size format: {}", size_str)))
+    }
+}
+
+fn matches_pattern(path: &str, pattern: &str) -> bool {
+    if pattern.ends_with("/*") {
+        let prefix = &pattern[..pattern.len() - 2];
+        path.starts_with(prefix)
+    } else if pattern.starts_with("*.") {
+        let suffix = &pattern[1..];
+        path.ends_with(suffix)
+    } else {
+        path == pattern
+    }
+}
+
+fn merge_configs(base: GurtConfig, override_config: GurtConfig) -> GurtConfig {
+    GurtConfig {
+        server: merge_server_configs(base.server, override_config.server),
+        tls: override_config.tls.or(base.tls),
+        logging: override_config.logging.or(base.logging),
+        security: override_config.security.or(base.security),
+        error_pages: override_config.error_pages.or(base.error_pages),
+        headers: override_config.headers.or(base.headers),
+    }
+}
+
+fn merge_server_configs(base: ServerConfig, override_config: ServerConfig) -> ServerConfig {
+    ServerConfig {
+        host: if override_config.host != default_host() { override_config.host } else { base.host },
+        port: if override_config.port != default_port() { override_config.port } else { base.port },
+        protocol_version: if override_config.protocol_version != default_protocol_version() { 
+            override_config.protocol_version 
+        } else { 
+            base.protocol_version 
+        },
+        alpn_identifier: if override_config.alpn_identifier != default_alpn_identifier() { 
+            override_config.alpn_identifier 
+        } else { 
+            base.alpn_identifier 
+        },
+        timeouts: override_config.timeouts.or(base.timeouts),
+        max_connections: if override_config.max_connections != default_max_connections() { 
+            override_config.max_connections 
+        } else { 
+            base.max_connections 
+        },
+        max_message_size: if override_config.max_message_size != default_max_message_size() { 
+            override_config.max_message_size 
+        } else { 
+            base.max_message_size 
+        },
+        base_directory: override_config.base_directory,
+        verbose: override_config.verbose,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_default_config_creation() {
+        let base_dir = PathBuf::from("/tmp");
+        let mut config = GurtConfig::default();
+        config.server.base_directory = Arc::new(base_dir.clone());
+        
+        assert_eq!(config.server.host, "127.0.0.1");
+        assert_eq!(config.server.port, 4878);
+        assert_eq!(config.server.protocol_version, "1.0.0");
+        assert_eq!(config.server.alpn_identifier, "GURT/1.0");
+        assert_eq!(*config.server.base_directory, base_dir);
+    }
+
+    #[test]
+    fn test_config_from_valid_toml() {
+        let toml_content = r#"
+[server]
+host = "0.0.0.0"
+port = 8080
+protocol_version = "2.0.0"
+alpn_identifier = "custom"
+max_connections = 1000
+max_message_size = "10MB"
+
+[security]
+rate_limit_requests = 60
+rate_limit_connections = 5
+"#;
+        
+        let base_dir = PathBuf::from("/tmp");
+        let config = GurtConfig::from_toml(toml_content, base_dir).unwrap();
+        
+        assert_eq!(config.server.host, "0.0.0.0");
+        assert_eq!(config.server.port, 8080);
+        assert_eq!(config.server.protocol_version, "2.0.0");
+        assert_eq!(config.server.alpn_identifier, "custom");
+        assert_eq!(config.server.max_connections, 1000);
+        
+        let security = config.security.unwrap();
+        assert_eq!(security.rate_limit_requests, 60);
+        assert_eq!(security.rate_limit_connections, 5);
+    }
+
+    #[test]
+    fn test_invalid_toml_returns_error() {
+        let invalid_toml = r#"
+[server
+host = "0.0.0.0"
+"#;
+        
+        let base_dir = PathBuf::from("/tmp");
+        let result = GurtConfig::from_toml(invalid_toml, base_dir);
+        
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_max_message_size_parsing() {
+        let config = GurtConfig::default();
+        
+        assert_eq!(parse_size("1024").unwrap(), 1024);
+        assert_eq!(parse_size("1KB").unwrap(), 1000);
+        assert_eq!(parse_size("1MB").unwrap(), 1000 * 1000);
+        assert_eq!(parse_size("1GB").unwrap(), 1000 * 1000 * 1000);
+        
+        assert!(parse_size("invalid").is_err());
+        
+        assert!(config.max_message_size_bytes().is_ok());
+    }
+
+    #[test]
+    fn test_tls_config_validation() {
+        let mut config = GurtConfig::default();
+        
+        config.tls = Some(TlsConfig {
+            certificate: PathBuf::from("/nonexistent/cert.pem"),
+            private_key: PathBuf::from("/nonexistent/key.pem"),
+        });
+        
+        assert!(config.tls.is_some());
+        let tls = config.tls.unwrap();
+        assert_eq!(tls.certificate, PathBuf::from("/nonexistent/cert.pem"));
+        assert_eq!(tls.private_key, PathBuf::from("/nonexistent/key.pem"));
+    }
+
+    #[test]
+    fn test_address_formatting() {
+        let config = GurtConfig::default();
+        assert_eq!(config.address(), "127.0.0.1:4878");
+        
+        let mut custom_config = GurtConfig::default();
+        custom_config.server.host = "0.0.0.0".to_string();
+        custom_config.server.port = 8080;
+        assert_eq!(custom_config.address(), "0.0.0.0:8080");
+    }
+
+    #[test]
+    fn test_timeout_getters() {
+        let config = GurtConfig::default();
+        
+        assert_eq!(config.get_handshake_timeout(), Duration::from_secs(5));
+        assert_eq!(config.get_request_timeout(), Duration::from_secs(30));
+        assert_eq!(config.get_connection_timeout(), Duration::from_secs(10));
+    }
+}