Feature/rustfs config (#396)

* init rustfs config

* improve code for rustfs-config crate

* add

* improve code for comment

* fix: modify rustfs-config crate name

* add default fn

* improve error logger

* fix: modify docker config yaml

* improve code for config

* feat: restrict kafka feature to Linux only

- Add target-specific feature configuration in Cargo.toml for obs and event-notifier crates
- Implement conditional compilation for kafka feature only on Linux systems
- Add appropriate error handling for non-Linux platforms
- Ensure backward compatibility with existing code

* refactor(ci): optimize build workflow for better efficiency

- Integrate GUI build steps into main build-rustfs job
- Add conditional GUI build execution based on tag releases
- Simplify workflow by removing redundant build-rustfs-gui job
- Copy binary directly to embedded-rustfs directory without downloading artifacts
- Update merge job dependency to only rely on build-rustfs
- Improve cross-platform compatibility for Windows binary naming (.exe)
- Streamline artifact uploading and OSS publishing process
- Maintain consistent conditional logic for release operations

* refactor(ci): optimize build workflow for better efficiency

- Integrate GUI build steps into main build-rustfs job
- Add conditional GUI build execution based on tag releases
- Simplify workflow by removing redundant build-rustfs-gui job
- Copy binary directly to embedded-rustfs directory without downloading artifacts
- Update merge job dependency to only rely on build-rustfs
- Improve cross-platform compatibility for Windows binary naming (.exe)
- Streamline artifact uploading and OSS publishing process
- Maintain consistent conditional logic for release operations

* fix(ci): add repo-token to setup-protoc action for authentication

- Add GITHUB_TOKEN parameter to arduino/setup-protoc@v3 action
- Ensure proper authentication for Protoc installation in CI workflow
- Maintain consistent setup across different CI environments

* modify config

* improve readme.md

* remove env config relation

* add allow(dead_code)

crates/config/src/config.rs

@@ -1,17 +1,17 @@
-use crate::event::config::EventConfig;
+use crate::event::config::NotifierConfig;
 use crate::ObservabilityConfig;
 
 /// RustFs configuration
 pub struct RustFsConfig {
     pub observability: ObservabilityConfig,
-    pub event: EventConfig,
+    pub event: NotifierConfig,
 }
 
 impl RustFsConfig {
     pub fn new() -> Self {
         Self {
             observability: ObservabilityConfig::new(),
-            event: EventConfig::new(),
+            event: NotifierConfig::new(),
         }
     }
 }

crates/config/src/constants/app.rs

@@ -14,6 +14,25 @@ pub const VERSION: &str = "0.0.1";
 /// Environment variable: RUSTFS_LOG_LEVEL
 pub const DEFAULT_LOG_LEVEL: &str = "info";
 
+/// Default configuration use stdout
+/// Default value: true
+pub(crate) const USE_STDOUT: bool = true;
+
+/// Default configuration sample ratio
+/// Default value: 1.0
+pub(crate) const SAMPLE_RATIO: f64 = 1.0;
+/// Default configuration meter interval
+/// Default value: 30
+pub(crate) const METER_INTERVAL: u64 = 30;
+
+/// Default configuration service version
+/// Default value: 0.0.1
+pub(crate) const SERVICE_VERSION: &str = "0.0.1";
+
+/// Default configuration environment
+/// Default value: production
+pub(crate) const ENVIRONMENT: &str = "production";
+
 /// maximum number of connections
 /// This is the maximum number of connections that the server will accept.
 /// This is used to limit the number of connections to the server.

crates/config/src/event/adapters.rs

@@ -0,0 +1,27 @@
+use crate::event::kafka::KafkaAdapter;
+use crate::event::mqtt::MqttAdapter;
+use crate::event::webhook::WebhookAdapter;
+use serde::{Deserialize, Serialize};
+
+/// Configuration for the notification system.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum AdapterConfig {
+    Webhook(WebhookAdapter),
+    Kafka(KafkaAdapter),
+    Mqtt(MqttAdapter),
+}
+
+impl AdapterConfig {
+    /// create a new configuration with default values
+    pub fn new() -> Self {
+        Self::Webhook(WebhookAdapter::new())
+    }
+}
+
+impl Default for AdapterConfig {
+    /// create a new configuration with default values
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/event/config.rs

@@ -1,23 +1,43 @@
-/// Event configuration module
-pub struct EventConfig {
-    pub event_type: String,
-    pub event_source: String,
-    pub event_destination: String,
+use crate::event::adapters::AdapterConfig;
+use serde::{Deserialize, Serialize};
+use std::env;
+
+#[allow(dead_code)]
+const DEFAULT_CONFIG_FILE: &str = "event";
+
+/// Configuration for the notification system.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NotifierConfig {
+    #[serde(default = "default_store_path")]
+    pub store_path: String,
+    #[serde(default = "default_channel_capacity")]
+    pub channel_capacity: usize,
+    pub adapters: Vec<AdapterConfig>,
 }
 
-impl EventConfig {
-    /// Creates a new instance of `EventConfig` with default values.
-    pub fn new() -> Self {
-        Self {
-            event_type: "default".to_string(),
-            event_source: "default".to_string(),
-            event_destination: "default".to_string(),
-        }
-    }
-}
-
-impl Default for EventConfig {
+impl Default for NotifierConfig {
     fn default() -> Self {
         Self::new()
     }
 }
+
+impl NotifierConfig {
+    /// create a new configuration with default values
+    pub fn new() -> Self {
+        Self {
+            store_path: default_store_path(),
+            channel_capacity: default_channel_capacity(),
+            adapters: vec![AdapterConfig::new()],
+        }
+    }
+}
+
+/// Provide temporary directories as default storage paths
+fn default_store_path() -> String {
+    env::temp_dir().join("event-notification").to_string_lossy().to_string()
+}
+
+/// Provides the recommended default channel capacity for high concurrency systems
+fn default_channel_capacity() -> usize {
+    10000 // Reasonable default values for high concurrency systems
+}

crates/config/src/event/event.rs

@@ -1,17 +0,0 @@
-/// Event configuration module
-pub struct EventConfig {
-    pub event_type: String,
-    pub event_source: String,
-    pub event_destination: String,
-}
-
-impl EventConfig {
-    /// Creates a new instance of `EventConfig` with default values.
-    pub fn new() -> Self {
-        Self {
-            event_type: "default".to_string(),
-            event_source: "default".to_string(),
-            event_destination: "default".to_string(),
-        }
-    }
-}

crates/config/src/event/kafka.rs

@@ -0,0 +1,29 @@
+use serde::{Deserialize, Serialize};
+
+/// Configuration for the Kafka adapter.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct KafkaAdapter {
+    pub brokers: String,
+    pub topic: String,
+    pub max_retries: u32,
+    pub timeout: u64,
+}
+
+impl KafkaAdapter {
+    /// create a new configuration with default values
+    pub fn new() -> Self {
+        Self {
+            brokers: "localhost:9092".to_string(),
+            topic: "kafka_topic".to_string(),
+            max_retries: 3,
+            timeout: 1000,
+        }
+    }
+}
+
+impl Default for KafkaAdapter {
+    /// create a new configuration with default values
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/event/mod.rs

@@ -1,2 +1,5 @@
+pub(crate) mod adapters;
 pub(crate) mod config;
-pub(crate) mod event;
+pub(crate) mod kafka;
+pub(crate) mod mqtt;
+pub(crate) mod webhook;

crates/config/src/event/mqtt.rs

@@ -0,0 +1,31 @@
+use serde::{Deserialize, Serialize};
+
+/// Configuration for the MQTT adapter.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MqttAdapter {
+    pub broker: String,
+    pub port: u16,
+    pub client_id: String,
+    pub topic: String,
+    pub max_retries: u32,
+}
+
+impl MqttAdapter {
+    /// create a new configuration with default values
+    pub fn new() -> Self {
+        Self {
+            broker: "localhost".to_string(),
+            port: 1883,
+            client_id: "mqtt_client".to_string(),
+            topic: "mqtt_topic".to_string(),
+            max_retries: 3,
+        }
+    }
+}
+
+impl Default for MqttAdapter {
+    /// create a new configuration with default values
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/event/webhook.rs

@@ -0,0 +1,51 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Configuration for the notification system.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WebhookAdapter {
+    pub endpoint: String,
+    pub auth_token: Option<String>,
+    pub custom_headers: Option<HashMap<String, String>>,
+    pub max_retries: u32,
+    pub timeout: u64,
+}
+
+impl WebhookAdapter {
+    /// verify that the configuration is valid
+    pub fn validate(&self) -> Result<(), String> {
+        // verify that endpoint cannot be empty
+        if self.endpoint.trim().is_empty() {
+            return Err("Webhook endpoint cannot be empty".to_string());
+        }
+
+        // verification timeout must be reasonable
+        if self.timeout == 0 {
+            return Err("Webhook timeout must be greater than 0".to_string());
+        }
+
+        // Verify that the maximum number of retry is reasonable
+        if self.max_retries > 10 {
+            return Err("Maximum retry count cannot exceed 10".to_string());
+        }
+
+        Ok(())
+    }
+
+    /// Get the default configuration
+    pub fn new() -> Self {
+        Self {
+            endpoint: "".to_string(),
+            auth_token: None,
+            custom_headers: Some(HashMap::new()),
+            max_retries: 3,
+            timeout: 1000,
+        }
+    }
+}
+
+impl Default for WebhookAdapter {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/lib.rs

@@ -7,3 +7,5 @@ mod observability;
 
 pub use config::RustFsConfig;
 pub use constants::app::*;
+
+pub use event::config::NotifierConfig;

crates/config/src/observability/config.rs

@@ -1,13 +1,13 @@
 use crate::observability::logger::LoggerConfig;
 use crate::observability::otel::OtelConfig;
 use crate::observability::sink::SinkConfig;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 /// Observability configuration
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct ObservabilityConfig {
     pub otel: OtelConfig,
-    pub sinks: SinkConfig,
+    pub sinks: Vec<SinkConfig>,
     pub logger: Option<LoggerConfig>,
 }
 
@@ -15,7 +15,7 @@ impl ObservabilityConfig {
     pub fn new() -> Self {
         Self {
             otel: OtelConfig::new(),
-            sinks: SinkConfig::new(),
+            sinks: vec![SinkConfig::new()],
             logger: Some(LoggerConfig::new()),
         }
     }

crates/config/src/observability/file.rs

@@ -0,0 +1,59 @@
+use serde::{Deserialize, Serialize};
+use std::env;
+
+/// File sink configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileSink {
+    pub path: String,
+    #[serde(default = "default_buffer_size")]
+    pub buffer_size: Option<usize>,
+    #[serde(default = "default_flush_interval_ms")]
+    pub flush_interval_ms: Option<u64>,
+    #[serde(default = "default_flush_threshold")]
+    pub flush_threshold: Option<usize>,
+}
+
+impl FileSink {
+    pub fn new() -> Self {
+        Self {
+            path: env::var("RUSTFS_SINKS_FILE_PATH")
+                .ok()
+                .filter(|s| !s.trim().is_empty())
+                .unwrap_or_else(default_path),
+            buffer_size: default_buffer_size(),
+            flush_interval_ms: default_flush_interval_ms(),
+            flush_threshold: default_flush_threshold(),
+        }
+    }
+}
+
+impl Default for FileSink {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn default_buffer_size() -> Option<usize> {
+    Some(8192)
+}
+fn default_flush_interval_ms() -> Option<u64> {
+    Some(1000)
+}
+fn default_flush_threshold() -> Option<usize> {
+    Some(100)
+}
+
+fn default_path() -> String {
+    let temp_dir = env::temp_dir().join("rustfs");
+
+    if let Err(e) = std::fs::create_dir_all(&temp_dir) {
+        eprintln!("Failed to create log directory: {}", e);
+        return "rustfs/rustfs.log".to_string();
+    }
+
+    temp_dir
+        .join("rustfs.log")
+        .to_str()
+        .unwrap_or("rustfs/rustfs.log")
+        .to_string()
+}

crates/config/src/observability/file_sink.rs

@@ -1,25 +0,0 @@
-use serde::Deserialize;
-
-/// File sink configuration
-#[derive(Debug, Deserialize, Clone)]
-pub struct FileSinkConfig {
-    pub path: String,
-    pub max_size: u64,
-    pub max_backups: u64,
-}
-
-impl FileSinkConfig {
-    pub fn new() -> Self {
-        Self {
-            path: "".to_string(),
-            max_size: 0,
-            max_backups: 0,
-        }
-    }
-}
-
-impl Default for FileSinkConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}

crates/config/src/observability/kafka.rs

@@ -0,0 +1,36 @@
+use serde::{Deserialize, Serialize};
+
+/// Kafka sink configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct KafkaSink {
+    pub brokers: String,
+    pub topic: String,
+    #[serde(default = "default_batch_size")]
+    pub batch_size: Option<usize>,
+    #[serde(default = "default_batch_timeout_ms")]
+    pub batch_timeout_ms: Option<u64>,
+}
+
+impl KafkaSink {
+    pub fn new() -> Self {
+        Self {
+            brokers: "localhost:9092".to_string(),
+            topic: "rustfs".to_string(),
+            batch_size: default_batch_size(),
+            batch_timeout_ms: default_batch_timeout_ms(),
+        }
+    }
+}
+
+impl Default for KafkaSink {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn default_batch_size() -> Option<usize> {
+    Some(100)
+}
+fn default_batch_timeout_ms() -> Option<u64> {
+    Some(1000)
+}

crates/config/src/observability/kafka_sink.rs

@@ -1,23 +0,0 @@
-use serde::Deserialize;
-
-/// Kafka sink configuration
-#[derive(Debug, Deserialize, Clone)]
-pub struct KafkaSinkConfig {
-    pub brokers: Vec<String>,
-    pub topic: String,
-}
-
-impl KafkaSinkConfig {
-    pub fn new() -> Self {
-        Self {
-            brokers: vec!["localhost:9092".to_string()],
-            topic: "rustfs".to_string(),
-        }
-    }
-}
-
-impl Default for KafkaSinkConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}

crates/config/src/observability/logger.rs

@@ -1,7 +1,7 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 /// Logger configuration
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct LoggerConfig {
     pub queue_capacity: Option<usize>,
 }

crates/config/src/observability/mod.rs

@@ -1,8 +1,7 @@
 pub(crate) mod config;
-pub(crate) mod file_sink;
-pub(crate) mod kafka_sink;
+pub(crate) mod file;
+pub(crate) mod kafka;
 pub(crate) mod logger;
-pub(crate) mod observability;
 pub(crate) mod otel;
 pub(crate) mod sink;
-pub(crate) mod webhook_sink;
+pub(crate) mod webhook;

crates/config/src/observability/observability.rs

@@ -1,22 +0,0 @@
-use crate::observability::logger::LoggerConfig;
-use crate::observability::otel::OtelConfig;
-use crate::observability::sink::SinkConfig;
-use serde::Deserialize;
-
-/// Observability configuration
-#[derive(Debug, Deserialize, Clone)]
-pub struct ObservabilityConfig {
-    pub otel: OtelConfig,
-    pub sinks: SinkConfig,
-    pub logger: Option<LoggerConfig>,
-}
-
-impl ObservabilityConfig {
-    pub fn new() -> Self {
-        Self {
-            otel: OtelConfig::new(),
-            sinks: SinkConfig::new(),
-            logger: Some(LoggerConfig::new()),
-        }
-    }
-}

crates/config/src/observability/otel.rs

@@ -1,22 +1,25 @@
-use serde::Deserialize;
+use crate::constants::app::{ENVIRONMENT, METER_INTERVAL, SAMPLE_RATIO, SERVICE_VERSION, USE_STDOUT};
+use crate::{APP_NAME, DEFAULT_LOG_LEVEL};
+use serde::{Deserialize, Serialize};
+use std::env;
 
 /// OpenTelemetry configuration
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct OtelConfig {
-    pub endpoint: String,
-    pub service_name: String,
-    pub service_version: String,
-    pub resource_attributes: Vec<String>,
+    pub endpoint: String,                    // Endpoint for metric collection
+    pub use_stdout: Option<bool>,            // Output to stdout
+    pub sample_ratio: Option<f64>,           // Trace sampling ratio
+    pub meter_interval: Option<u64>,         // Metric collection interval
+    pub service_name: Option<String>,        // Service name
+    pub service_version: Option<String>,     // Service version
+    pub environment: Option<String>,         // Environment
+    pub logger_level: Option<String>,        // Logger level
+    pub local_logging_enabled: Option<bool>, // Local logging enabled
 }
 
 impl OtelConfig {
     pub fn new() -> Self {
-        Self {
-            endpoint: "http://localhost:4317".to_string(),
-            service_name: "rustfs".to_string(),
-            service_version: "0.1.0".to_string(),
-            resource_attributes: vec![],
-        }
+        extract_otel_config_from_env()
     }
 }
 
@@ -25,3 +28,42 @@ impl Default for OtelConfig {
         Self::new()
     }
 }
+
+// Helper function: Extract observable configuration from environment variables
+fn extract_otel_config_from_env() -> OtelConfig {
+    OtelConfig {
+        endpoint: env::var("RUSTFS_OBSERVABILITY_ENDPOINT").unwrap_or_else(|_| "".to_string()),
+        use_stdout: env::var("RUSTFS_OBSERVABILITY_USE_STDOUT")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(USE_STDOUT)),
+        sample_ratio: env::var("RUSTFS_OBSERVABILITY_SAMPLE_RATIO")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(SAMPLE_RATIO)),
+        meter_interval: env::var("RUSTFS_OBSERVABILITY_METER_INTERVAL")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(METER_INTERVAL)),
+        service_name: env::var("RUSTFS_OBSERVABILITY_SERVICE_NAME")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(APP_NAME.to_string())),
+        service_version: env::var("RUSTFS_OBSERVABILITY_SERVICE_VERSION")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(SERVICE_VERSION.to_string())),
+        environment: env::var("RUSTFS_OBSERVABILITY_ENVIRONMENT")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(ENVIRONMENT.to_string())),
+        logger_level: env::var("RUSTFS_OBSERVABILITY_LOGGER_LEVEL")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(DEFAULT_LOG_LEVEL.to_string())),
+        local_logging_enabled: env::var("RUSTFS_OBSERVABILITY_LOCAL_LOGGING_ENABLED")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .or(Some(false)),
+    }
+}

crates/config/src/observability/sink.rs

@@ -1,23 +1,20 @@
-use crate::observability::file_sink::FileSinkConfig;
-use crate::observability::kafka_sink::KafkaSinkConfig;
-use crate::observability::webhook_sink::WebhookSinkConfig;
-use serde::Deserialize;
+use crate::observability::file::FileSink;
+use crate::observability::kafka::KafkaSink;
+use crate::observability::webhook::WebhookSink;
+use serde::{Deserialize, Serialize};
 
 /// Sink configuration
-#[derive(Debug, Deserialize, Clone)]
-pub struct SinkConfig {
-    pub kafka: Option<KafkaSinkConfig>,
-    pub webhook: Option<WebhookSinkConfig>,
-    pub file: Option<FileSinkConfig>,
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum SinkConfig {
+    Kafka(KafkaSink),
+    Webhook(WebhookSink),
+    File(FileSink),
 }
 
 impl SinkConfig {
     pub fn new() -> Self {
-        Self {
-            kafka: None,
-            webhook: None,
-            file: Some(FileSinkConfig::new()),
-        }
+        Self::File(FileSink::new())
     }
 }
 

crates/config/src/observability/webhook.rs

@@ -0,0 +1,39 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Webhook sink configuration
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct WebhookSink {
+    pub endpoint: String,
+    pub auth_token: String,
+    pub headers: Option<HashMap<String, String>>,
+    #[serde(default = "default_max_retries")]
+    pub max_retries: Option<usize>,
+    #[serde(default = "default_retry_delay_ms")]
+    pub retry_delay_ms: Option<u64>,
+}
+
+impl WebhookSink {
+    pub fn new() -> Self {
+        Self {
+            endpoint: "".to_string(),
+            auth_token: "".to_string(),
+            headers: Some(HashMap::new()),
+            max_retries: default_max_retries(),
+            retry_delay_ms: default_retry_delay_ms(),
+        }
+    }
+}
+
+impl Default for WebhookSink {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn default_max_retries() -> Option<usize> {
+    Some(3)
+}
+fn default_retry_delay_ms() -> Option<u64> {
+    Some(100)
+}

crates/config/src/observability/webhook_sink.rs

@@ -1,25 +0,0 @@
-use serde::Deserialize;
-
-/// Webhook sink configuration
-#[derive(Debug, Deserialize, Clone)]
-pub struct WebhookSinkConfig {
-    pub url: String,
-    pub method: String,
-    pub headers: Vec<(String, String)>,
-}
-
-impl WebhookSinkConfig {
-    pub fn new() -> Self {
-        Self {
-            url: "http://localhost:8080/webhook".to_string(),
-            method: "POST".to_string(),
-            headers: vec![],
-        }
-    }
-}
-
-impl Default for WebhookSinkConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}