refactor: standardize constant management and fix typos (#387)

* init rustfs config

* init rustfs-utils crate

* improve code for rustfs-config crate

* add

* improve code for comment

* init rustfs config

* improve code for rustfs-config crate

* add

* improve code for comment

* Unified management of configurations and constants

* fix: modify rustfs-config crate name

* add default fn

* improve code for rustfs config

* refactor: standardize constant management and fix typos

- Create centralized constants module for global static constants
- Replace runtime format! expressions with compile-time constants
- Fix DEFAULT_PORT reference issues in configuration arguments
- Use const-str crate for compile-time string concatenation
- Update tokio dependency from 1.42.2 to 1.45.0
- Ensure consistent naming convention for configuration constants

* fix

* Update common/workers/src/workers.rs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

crates/config/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "rustfs-config"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+config = { workspace = true }
+const-str = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+
+
+[lints]
+workspace = true

crates/config/src/config.rs

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

crates/config/src/constants/app.rs

@@ -0,0 +1,72 @@
+use const_str::concat;
+
+/// Application name
+/// Default value: RustFs
+/// Environment variable: RUSTFS_APP_NAME
+pub const APP_NAME: &str = "RustFs";
+/// Application version
+/// Default value: 1.0.0
+/// Environment variable: RUSTFS_VERSION
+pub const VERSION: &str = "0.0.1";
+
+/// Default configuration logger level
+/// Default value: info
+/// Environment variable: RUSTFS_LOG_LEVEL
+pub const DEFAULT_LOG_LEVEL: &str = "info";
+
+/// 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.
+pub const MAX_CONNECTIONS: usize = 100;
+/// timeout for connections
+/// This is the timeout for connections to the server.
+/// This is used to limit the time that a connection can be open.
+pub const DEFAULT_TIMEOUT_MS: u64 = 3000;
+
+/// Default Access Key
+/// Default value: rustfsadmin
+/// Environment variable: RUSTFS_ACCESS_KEY
+/// Command line argument: --access-key
+/// Example: RUSTFS_ACCESS_KEY=rustfsadmin
+/// Example: --access-key rustfsadmin
+pub const DEFAULT_ACCESS_KEY: &str = "rustfsadmin";
+/// Default Secret Key
+/// Default value: rustfsadmin
+/// Environment variable: RUSTFS_SECRET_KEY
+/// Command line argument: --secret-key
+/// Example: RUSTFS_SECRET_KEY=rustfsadmin
+/// Example: --secret-key rustfsadmin
+pub const DEFAULT_SECRET_KEY: &str = "rustfsadmin";
+/// Default configuration file for observability
+/// Default value: config/obs.toml
+/// Environment variable: RUSTFS_OBS_CONFIG
+/// Command line argument: --obs-config
+/// Example: RUSTFS_OBS_CONFIG=config/obs.toml
+/// Example: --obs-config config/obs.toml
+/// Example: --obs-config /etc/rustfs/obs.toml
+pub const DEFAULT_OBS_CONFIG: &str = "config/obs.toml";
+
+/// Default TLS key for rustfs
+/// This is the default key for TLS.
+pub const RUSTFS_TLS_KEY: &str = "rustfs_key.pem";
+
+/// Default TLS cert for rustfs
+/// This is the default cert for TLS.
+pub const RUSTFS_TLS_CERT: &str = "rustfs_cert.pem";
+
+/// Default port for rustfs
+/// This is the default port for rustfs.
+/// This is used to bind the server to a specific port.
+pub const DEFAULT_PORT: u16 = 9000;
+
+/// Default address for rustfs
+/// This is the default address for rustfs.
+pub const DEFAULT_ADDRESS: &str = concat!(":", DEFAULT_PORT);
+
+/// Default port for rustfs console
+/// This is the default port for rustfs console.
+pub const DEFAULT_CONSOLE_PORT: u16 = 9002;
+
+/// Default address for rustfs console
+/// This is the default address for rustfs console.
+pub const DEFAULT_CONSOLE_ADDRESS: &str = concat!(":", DEFAULT_CONSOLE_PORT);

crates/config/src/constants/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod app;

crates/config/src/event/config.rs

@@ -0,0 +1,23 @@
+/// 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(),
+        }
+    }
+}
+
+impl Default for EventConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/event/event.rs

@@ -0,0 +1,17 @@
+/// 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/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod config;
+pub(crate) mod event;

crates/config/src/lib.rs

@@ -0,0 +1,9 @@
+use crate::observability::config::ObservabilityConfig;
+
+mod config;
+mod constants;
+mod event;
+mod observability;
+
+pub use config::RustFsConfig;
+pub use constants::app::*;

crates/config/src/observability/config.rs

@@ -0,0 +1,28 @@
+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()),
+        }
+    }
+}
+
+impl Default for ObservabilityConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/observability/file_sink.rs

@@ -0,0 +1,25 @@
+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_sink.rs

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,21 @@
+use serde::Deserialize;
+
+/// Logger configuration
+#[derive(Debug, Deserialize, Clone)]
+pub struct LoggerConfig {
+    pub queue_capacity: Option<usize>,
+}
+
+impl LoggerConfig {
+    pub fn new() -> Self {
+        Self {
+            queue_capacity: Some(10000),
+        }
+    }
+}
+
+impl Default for LoggerConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/observability/mod.rs

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

crates/config/src/observability/observability.rs

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,27 @@
+use serde::Deserialize;
+
+/// OpenTelemetry configuration
+#[derive(Debug, Deserialize, Clone)]
+pub struct OtelConfig {
+    pub endpoint: String,
+    pub service_name: String,
+    pub service_version: String,
+    pub resource_attributes: Vec<String>,
+}
+
+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![],
+        }
+    }
+}
+
+impl Default for OtelConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/observability/sink.rs

@@ -0,0 +1,28 @@
+use crate::observability::file_sink::FileSinkConfig;
+use crate::observability::kafka_sink::KafkaSinkConfig;
+use crate::observability::webhook_sink::WebhookSinkConfig;
+use serde::Deserialize;
+
+/// Sink configuration
+#[derive(Debug, Deserialize, Clone)]
+pub struct SinkConfig {
+    pub kafka: Option<KafkaSinkConfig>,
+    pub webhook: Option<WebhookSinkConfig>,
+    pub file: Option<FileSinkConfig>,
+}
+
+impl SinkConfig {
+    pub fn new() -> Self {
+        Self {
+            kafka: None,
+            webhook: None,
+            file: Some(FileSinkConfig::new()),
+        }
+    }
+}
+
+impl Default for SinkConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/config/src/observability/webhook_sink.rs

@@ -0,0 +1,25 @@
+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()
+    }
+}

crates/event-notifier/src/config.rs

@@ -162,7 +162,7 @@ impl NotifierConfig {
     }
 }
 
-const DEFAULT_CONFIG_FILE: &str = "obs";
+const DEFAULT_CONFIG_FILE: &str = "event";
 
 /// Provide temporary directories as default storage paths
 fn default_store_path() -> String {

crates/event-notifier/src/event.rs

@@ -154,16 +154,6 @@ impl Default for Metadata {
     }
 }
 impl Metadata {
-    /// Create a new Metadata instance
-    pub fn create(schema_version: String, configuration_id: String, bucket: Bucket, object: Object) -> Self {
-        Self {
-            schema_version,
-            configuration_id,
-            bucket,
-            object,
-        }
-    }
-
     /// Create a new Metadata instance with default values
     pub fn new() -> Self {
         Self {
@@ -178,6 +168,16 @@ impl Metadata {
         }
     }
 
+    /// Create a new Metadata instance
+    pub fn create(schema_version: String, configuration_id: String, bucket: Bucket, object: Object) -> Self {
+        Self {
+            schema_version,
+            configuration_id,
+            bucket,
+            object,
+        }
+    }
+
     /// Set the schema version
     pub fn set_schema_version(&mut self, schema_version: String) {
         self.schema_version = schema_version;
@@ -470,17 +470,7 @@ pub struct Log {
     pub records: Vec<Event>,
 }
 
-#[derive(
-    Debug,
-    Clone,
-    Copy,
-    PartialEq,
-    Eq,
-    SerializeDisplay,
-    DeserializeFromStr,
-    Display,
-    EnumString
-)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, SerializeDisplay, DeserializeFromStr, Display, EnumString)]
 #[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
 pub enum Name {
     ObjectAccessedGet,

crates/utils/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rustfs-utils"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+local-ip-address = { workspace = true }
+rustfs-config = { workspace = true }
+rustls = { workspace = true }
+rustls-pemfile = { workspace = true }
+rustls-pki-types = { workspace = true }
+tracing = { workspace = true }
+
+[lints]
+workspace = true

crates/utils/src/certs.rs

@@ -0,0 +1,186 @@
+use rustfs_config::{RUSTFS_TLS_CERT, RUSTFS_TLS_KEY};
+use rustls::server::{ClientHello, ResolvesServerCert, ResolvesServerCertUsingSni};
+use rustls::sign::CertifiedKey;
+use rustls_pemfile::{certs, private_key};
+use rustls_pki_types::{CertificateDer, PrivateKeyDer};
+use std::collections::HashMap;
+use std::io::Error;
+use std::path::Path;
+use std::sync::Arc;
+use std::{fs, io};
+use tracing::{debug, warn};
+
+/// Load public certificate from file.
+/// This function loads a public certificate from the specified file.
+pub fn load_certs(filename: &str) -> io::Result<Vec<CertificateDer<'static>>> {
+    // Open certificate file.
+    let cert_file = fs::File::open(filename).map_err(|e| certs_error(format!("failed to open {}: {}", filename, e)))?;
+    let mut reader = io::BufReader::new(cert_file);
+
+    // Load and return certificate.
+    let certs = certs(&mut reader)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|_| certs_error(format!("certificate file {} format error", filename)))?;
+    if certs.is_empty() {
+        return Err(certs_error(format!(
+            "No valid certificate was found in the certificate file {}",
+            filename
+        )));
+    }
+    Ok(certs)
+}
+
+/// Load private key from file.
+/// This function loads a private key from the specified file.
+pub fn load_private_key(filename: &str) -> io::Result<PrivateKeyDer<'static>> {
+    // Open keyfile.
+    let keyfile = fs::File::open(filename).map_err(|e| certs_error(format!("failed to open {}: {}", filename, e)))?;
+    let mut reader = io::BufReader::new(keyfile);
+
+    // Load and return a single private key.
+    private_key(&mut reader)?.ok_or_else(|| certs_error(format!("no private key found in {}", filename)))
+}
+
+/// error function
+pub fn certs_error(err: String) -> Error {
+    Error::new(io::ErrorKind::Other, err)
+}
+
+/// Load all certificates and private keys in the directory
+/// This function loads all certificate and private key pairs from the specified directory.
+/// It looks for files named `rustfs_cert.pem` and `rustfs_key.pem` in each subdirectory.
+/// The root directory can also contain a default certificate/private key pair.
+pub fn load_all_certs_from_directory(
+    dir_path: &str,
+) -> io::Result<HashMap<String, (Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)>> {
+    let mut cert_key_pairs = HashMap::new();
+    let dir = Path::new(dir_path);
+
+    if !dir.exists() || !dir.is_dir() {
+        return Err(certs_error(format!(
+            "The certificate directory does not exist or is not a directory: {}",
+            dir_path
+        )));
+    }
+
+    // 1. First check whether there is a certificate/private key pair in the root directory
+    let root_cert_path = dir.join(RUSTFS_TLS_CERT);
+    let root_key_path = dir.join(RUSTFS_TLS_KEY);
+
+    if root_cert_path.exists() && root_key_path.exists() {
+        debug!("find the root directory certificate: {:?}", root_cert_path);
+        let root_cert_str = root_cert_path
+            .to_str()
+            .ok_or_else(|| certs_error(format!("Invalid UTF-8 in root certificate path: {:?}", root_cert_path)))?;
+        let root_key_str = root_key_path
+            .to_str()
+            .ok_or_else(|| certs_error(format!("Invalid UTF-8 in root key path: {:?}", root_key_path)))?;
+        match load_cert_key_pair(root_cert_str, root_key_str) {
+            Ok((certs, key)) => {
+                // The root directory certificate is used as the default certificate and is stored using special keys.
+                cert_key_pairs.insert("default".to_string(), (certs, key));
+            }
+            Err(e) => {
+                warn!("unable to load root directory certificate: {}", e);
+            }
+        }
+    }
+
+    // 2.iterate through all folders in the directory
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+
+        if path.is_dir() {
+            let domain_name = path
+                .file_name()
+                .and_then(|name| name.to_str())
+                .ok_or_else(|| certs_error(format!("invalid domain name directory:{:?}", path)))?;
+
+            // find certificate and private key files
+            let cert_path = path.join(RUSTFS_TLS_CERT); // e.g., rustfs_cert.pem
+            let key_path = path.join(RUSTFS_TLS_KEY); // e.g., rustfs_key.pem
+
+            if cert_path.exists() && key_path.exists() {
+                debug!("find the domain name certificate: {} in {:?}", domain_name, cert_path);
+                match load_cert_key_pair(cert_path.to_str().unwrap(), key_path.to_str().unwrap()) {
+                    Ok((certs, key)) => {
+                        cert_key_pairs.insert(domain_name.to_string(), (certs, key));
+                    }
+                    Err(e) => {
+                        warn!("unable to load the certificate for {} domain name: {}", domain_name, e);
+                    }
+                }
+            }
+        }
+    }
+
+    if cert_key_pairs.is_empty() {
+        return Err(certs_error(format!(
+            "No valid certificate/private key pair found in directory {}",
+            dir_path
+        )));
+    }
+
+    Ok(cert_key_pairs)
+}
+
+/// loading a single certificate private key pair
+/// This function loads a certificate and private key from the specified paths.
+/// It returns a tuple containing the certificate and private key.
+fn load_cert_key_pair(cert_path: &str, key_path: &str) -> io::Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)> {
+    let certs = load_certs(cert_path)?;
+    let key = load_private_key(key_path)?;
+    Ok((certs, key))
+}
+
+/// Create a multi-cert resolver
+/// This function loads all certificates and private keys from the specified directory.
+/// It uses the first certificate/private key pair found in the root directory as the default certificate.
+/// The rest of the certificates/private keys are used for SNI resolution.
+///
+pub fn create_multi_cert_resolver(
+    cert_key_pairs: HashMap<String, (Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)>,
+) -> io::Result<impl ResolvesServerCert> {
+    #[derive(Debug)]
+    struct MultiCertResolver {
+        cert_resolver: ResolvesServerCertUsingSni,
+        default_cert: Option<Arc<CertifiedKey>>,
+    }
+    impl ResolvesServerCert for MultiCertResolver {
+        fn resolve(&self, client_hello: ClientHello) -> Option<Arc<CertifiedKey>> {
+            // try matching certificates with sni
+            if let Some(cert) = self.cert_resolver.resolve(client_hello) {
+                return Some(cert);
+            }
+
+            // If there is no matching SNI certificate, use the default certificate
+            self.default_cert.clone()
+        }
+    }
+
+    let mut resolver = ResolvesServerCertUsingSni::new();
+    let mut default_cert = None;
+
+    for (domain, (certs, key)) in cert_key_pairs {
+        // create a signature
+        let signing_key = rustls::crypto::aws_lc_rs::sign::any_supported_type(&key)
+            .map_err(|_| certs_error(format!("unsupported private key types:{}", domain)))?;
+
+        // create a CertifiedKey
+        let certified_key = CertifiedKey::new(certs, signing_key);
+        if domain == "default" {
+            default_cert = Some(Arc::new(certified_key.clone()));
+        } else {
+            // add certificate to resolver
+            resolver
+                .add(&domain, certified_key)
+                .map_err(|e| certs_error(format!("failed to add a domain name certificate:{},err: {:?}", domain, e)))?;
+        }
+    }
+
+    Ok(MultiCertResolver {
+        cert_resolver: resolver,
+        default_cert,
+    })
+}

crates/utils/src/ip.rs

@@ -0,0 +1,43 @@
+use std::net::{IpAddr, Ipv4Addr};
+
+/// Get the IP address of the machine
+///
+/// Priority is given to trying to get the IPv4 address, and if it fails, try to get the IPv6 address.
+/// If both fail to retrieve, None is returned.
+///
+/// # Returns
+///
+/// * `Some(IpAddr)` - Native IP address (IPv4 or IPv6)
+/// * `None` - Unable to obtain any native IP address
+pub fn get_local_ip() -> Option<IpAddr> {
+    local_ip_address::local_ip()
+        .ok()
+        .or_else(|| local_ip_address::local_ipv6().ok())
+}
+
+/// Get the IP address of the machine as a string
+///
+/// If the IP address cannot be obtained, returns "127.0.0.1" as the default value.
+///
+/// # Returns
+///
+/// * `String` - Native IP address (IPv4 or IPv6) as a string, or the default value
+pub fn get_local_ip_with_default() -> String {
+    get_local_ip()
+        .unwrap_or_else(|| IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))) // Provide a safe default value
+        .to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_local_ip() {
+        match get_local_ip() {
+            Some(ip) => println!("the ip address of this machine:{}", ip),
+            None => println!("Unable to obtain the IP address of the machine"),
+        }
+        assert!(get_local_ip().is_some());
+    }
+}

crates/utils/src/lib.rs

@@ -0,0 +1,11 @@
+mod certs;
+mod ip;
+mod net;
+
+pub use certs::certs_error;
+pub use certs::create_multi_cert_resolver;
+pub use certs::load_all_certs_from_directory;
+pub use certs::load_certs;
+pub use certs::load_private_key;
+pub use ip::get_local_ip;
+pub use ip::get_local_ip_with_default;