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>

rustfs/Cargo.toml

@@ -30,7 +30,7 @@ clap.workspace = true
 crypto = { workspace = true }
 datafusion = { workspace = true }
 common.workspace = true
-const-str = { version = "0.6.1", features = ["std", "proc"] }
+const-str = { workspace = true }
 ecstore.workspace = true
 policy.workspace = true
 flatbuffers.workspace = true
@@ -42,7 +42,6 @@ http.workspace = true
 http-body.workspace = true
 iam = { workspace = true }
 lock.workspace = true
-local-ip-address = { workspace = true }
 matchit = { workspace = true }
 mime.workspace = true
 mime_guess = { workspace = true }
@@ -51,18 +50,18 @@ pin-project-lite.workspace = true
 protos.workspace = true
 query = { workspace = true }
 rmp-serde.workspace = true
+rustfs-config = { workspace = true }
 rustfs-event-notifier = { workspace = true }
 rustfs-obs = { workspace = true }
+rustfs-utils = { workspace = true }
 rustls.workspace = true
-rustls-pemfile.workspace = true
-rustls-pki-types.workspace = true
 rust-embed = { workspace = true, features = ["interpolate-folder-path"] }
 s3s.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 serde_urlencoded = { workspace = true }
 shadow-rs = { workspace = true, features = ["build", "metadata"] }
-socket2 = "0.5.9"
+socket2 = { workspace = true }
 tracing.workspace = true
 time = { workspace = true, features = ["parsing", "formatting", "serde"] }
 tokio-util.workspace = true

rustfs/README.md

@@ -1,30 +1,36 @@
-rustfs/
-├── Cargo.toml
-├── src/
-│ ├── main.rs # 主入口
-│ ├── admin/
-│ │ └── mod.rs # 管理接口
-│ ├── auth/
-│ │ └── mod.rs # 认证模块
-│ ├── config/
-│ │ ├── mod.rs # 配置模块
-│ │ └── options.rs # 命令行参数
-│ ├── console/
-│ │ ├── mod.rs # 控制台模块
-│ │ └── server.rs # 控制台服务器
-│ ├── grpc/
-│ │ └── mod.rs # gRPC 服务
-│ ├── license/
-│ │ └── mod.rs # 许可证管理
-│ ├── logging/
-│ │ └── mod.rs # 日志管理
-│ ├── server/
-│ │ ├── mod.rs # 服务器实现
-│ │ ├── connection.rs # 连接处理
-│ │ ├── service.rs # 服务实现
-│ │ └── state.rs # 状态管理
-│ ├── storage/
-│ │ ├── mod.rs # 存储模块
-│ │ └── fs.rs # 文件系统实现
-│ └── utils/
-│ └── mod.rs # 工具函数
+# RustFS
+
+RustFS is a simple file system written in Rust. It is designed to be a learning project for those who want to understand
+how file systems work and how to implement them in Rust.
+
+## Features
+
+- Simple file system structure
+- Basic file operations (create, read, write, delete)
+- Directory support
+- File metadata (size, creation time, etc.)
+- Basic error handling
+- Unit tests for core functionality
+- Documentation for public API
+- Example usage
+- License information
+- Contributing guidelines
+- Changelog
+- Code of conduct
+- Acknowledgements
+- Contact information
+- Links to additional resources
+
+## Getting Started
+
+To get started with RustFS, clone the repository and build the project:
+
+```bash
+git clone git@github.com:rustfs/s3-rustfs.git
+cd rustfs
+cargo build
+```
+
+## Usage
+
+To use RustFS, you can create a new file system instance and perform basic file operations. Here is an example:

rustfs/src/config/mod.rs

@@ -1,40 +1,8 @@
 use clap::Parser;
 use const_str::concat;
-use ecstore::global::DEFAULT_PORT;
 use std::string::ToString;
 shadow_rs::shadow!(build);
 
-/// 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(crate) const RUSTFS_TLS_KEY: &str = "rustfs_key.pem";
-
-/// Default TLS cert for rustfs
-/// This is the default cert for TLS.
-pub(crate) const RUSTFS_TLS_CERT: &str = "rustfs_cert.pem";
-
 #[allow(clippy::const_is_empty)]
 const SHORT_VERSION: &str = {
     if !build::TAG.is_empty() {
@@ -67,7 +35,7 @@ pub struct Opt {
     pub volumes: Vec<String>,
 
     /// bind to a specific ADDRESS:PORT, ADDRESS can be an IP or hostname
-    #[arg(long, default_value_t = format!("0.0.0.0:{}", DEFAULT_PORT), env = "RUSTFS_ADDRESS")]
+    #[arg(long, default_value_t = rustfs_config::DEFAULT_ADDRESS.to_string(), env = "RUSTFS_ADDRESS")]
     pub address: String,
 
     /// Domain name used for virtual-hosted-style requests.
@@ -75,17 +43,19 @@ pub struct Opt {
     pub server_domains: Vec<String>,
 
     /// Access key used for authentication.
-    #[arg(long, default_value_t = DEFAULT_ACCESS_KEY.to_string(), env = "RUSTFS_ACCESS_KEY")]
+    #[arg(long, default_value_t = rustfs_config::DEFAULT_ACCESS_KEY.to_string(), env = "RUSTFS_ACCESS_KEY")]
     pub access_key: String,
 
     /// Secret key used for authentication.
-    #[arg(long, default_value_t = DEFAULT_SECRET_KEY.to_string(), env = "RUSTFS_SECRET_KEY")]
+    #[arg(long, default_value_t = rustfs_config::DEFAULT_SECRET_KEY.to_string(), env = "RUSTFS_SECRET_KEY")]
     pub secret_key: String,
 
+    /// Enable console server
     #[arg(long, default_value_t = false, env = "RUSTFS_CONSOLE_ENABLE")]
     pub console_enable: bool,
 
-    #[arg(long, default_value_t = format!("127.0.0.1:{}", 9002), env = "RUSTFS_CONSOLE_ADDRESS")]
+    /// Console server bind address
+    #[arg(long, default_value_t = rustfs_config::DEFAULT_CONSOLE_ADDRESS.to_string(), env = "RUSTFS_CONSOLE_ADDRESS")]
     pub console_address: String,
 
     /// rustfs endpoint for console
@@ -94,7 +64,7 @@ pub struct Opt {
 
     /// Observability configuration file
     /// Default value: config/obs.toml
-    #[arg(long, default_value_t = DEFAULT_OBS_CONFIG.to_string(), env = "RUSTFS_OBS_CONFIG")]
+    #[arg(long, default_value_t = rustfs_config::DEFAULT_OBS_CONFIG.to_string(), env = "RUSTFS_OBS_CONFIG")]
     pub obs_config: String,
 
     /// tls path for rustfs api and console.

rustfs/src/console.rs

@@ -1,4 +1,3 @@
-use crate::config::{RUSTFS_TLS_CERT, RUSTFS_TLS_KEY};
 use crate::license::get_license;
 use axum::{
     body::Body,
@@ -8,6 +7,7 @@ use axum::{
     Router,
 };
 use axum_extra::extract::Host;
+use rustfs_config::{RUSTFS_TLS_CERT, RUSTFS_TLS_KEY};
 use std::io;
 
 use axum::response::Redirect;
@@ -17,7 +17,7 @@ use mime_guess::from_path;
 use rust_embed::RustEmbed;
 use serde::Serialize;
 use shadow_rs::shadow;
-use std::net::{Ipv4Addr, SocketAddr};
+use std::net::{IpAddr, SocketAddr};
 use std::sync::OnceLock;
 use std::time::Duration;
 use tokio::signal;
@@ -73,7 +73,7 @@ pub(crate) struct Config {
 }
 
 impl Config {
-    fn new(local_ip: Ipv4Addr, port: u16, version: &str, date: &str) -> Self {
+    fn new(local_ip: IpAddr, port: u16, version: &str, date: &str) -> Self {
         Config {
             port,
             api: Api {
@@ -144,7 +144,7 @@ struct License {
 pub(crate) static CONSOLE_CONFIG: OnceLock<Config> = OnceLock::new();
 
 #[allow(clippy::const_is_empty)]
-pub(crate) fn init_console_cfg(local_ip: Ipv4Addr, port: u16) {
+pub(crate) fn init_console_cfg(local_ip: IpAddr, port: u16) {
     CONSOLE_CONFIG.get_or_init(|| {
         let ver = {
             if !build::TAG.is_empty() {
@@ -220,7 +220,7 @@ async fn config_handler(uri: Uri, Host(host): Host) -> impl IntoResponse {
 
 pub async fn start_static_file_server(
     addrs: &str,
-    local_ip: Ipv4Addr,
+    local_ip: IpAddr,
     access_key: &str,
     secret_key: &str,
     tls_path: Option<String>,

rustfs/src/event.rs

@@ -0,0 +1,21 @@
+use rustfs_event_notifier::NotifierConfig;
+use tracing::{error, info, instrument};
+
+#[instrument]
+pub(crate) async fn init_event_notifier(notifier_config: Option<String>) {
+    // Initialize event notifier
+    if notifier_config.is_some() {
+        info!("event_config is not empty");
+        tokio::spawn(async move {
+            let config = NotifierConfig::event_load_config(notifier_config);
+            let result = rustfs_event_notifier::initialize(config).await;
+            if let Err(e) = result {
+                error!("Failed to initialize event notifier: {}", e);
+            } else {
+                info!("Event notifier initialized successfully");
+            }
+        });
+    } else {
+        info!("event_config is empty");
+    }
+}

rustfs/src/main.rs

@@ -2,18 +2,18 @@ mod admin;
 mod auth;
 mod config;
 mod console;
+mod event;
 mod grpc;
 pub mod license;
 mod logging;
 mod server;
 mod service;
 mod storage;
-mod utils;
+
 use crate::auth::IAMAuth;
 use crate::console::{init_console_cfg, CONSOLE_CONFIG};
 // Ensure the correct path for parse_license is imported
 use crate::server::{wait_for_shutdown, ServiceState, ServiceStateManager, ShutdownSignal, SHUTDOWN_TIMEOUT};
-use crate::utils::error;
 use bytes::Bytes;
 use chrono::Datelike;
 use clap::Parser;
@@ -21,7 +21,6 @@ use common::{
     error::{Error, Result},
     globals::set_global_addr,
 };
-use config::{DEFAULT_ACCESS_KEY, DEFAULT_SECRET_KEY, RUSTFS_TLS_CERT, RUSTFS_TLS_KEY};
 use ecstore::bucket::metadata_sys::init_bucket_metadata_sys;
 use ecstore::config as ecconfig;
 use ecstore::config::GLOBAL_ConfigSys;
@@ -48,7 +47,7 @@ use hyper_util::{
 use iam::init_iam_sys;
 use license::init_license;
 use protos::proto_gen::node_service::node_service_server::NodeServiceServer;
-use rustfs_event_notifier::NotifierConfig;
+use rustfs_config::{DEFAULT_ACCESS_KEY, DEFAULT_SECRET_KEY, RUSTFS_TLS_CERT, RUSTFS_TLS_KEY};
 use rustfs_obs::{init_obs, init_process_observer, load_config, set_global_guard};
 use rustls::ServerConfig;
 use s3s::{host::MultiDomain, service::S3ServiceBuilder};
@@ -85,7 +84,7 @@ fn print_server_info() {
     let cfg = CONSOLE_CONFIG.get().unwrap();
     let current_year = chrono::Utc::now().year();
 
-    // 使用自定义宏打印服务器信息
+    // Use custom macros to print server information
     info!("RustFS Object Storage Server");
     info!("Copyright: 2024-{} RustFS, Inc", current_year);
     info!("License: {}", cfg.license());
@@ -114,32 +113,12 @@ async fn main() -> Result<()> {
     run(opt).await
 }
 
-#[instrument]
-async fn init_event_notifier(notifier_config: Option<String>) {
-    // Initialize event notifier
-    if notifier_config.is_some() {
-        info!("event_config is not empty");
-        tokio::spawn(async move {
-            let config = NotifierConfig::event_load_config(notifier_config);
-            let result = rustfs_event_notifier::initialize(config).await;
-            if let Err(e) = result {
-                error!("Failed to initialize event notifier: {}", e);
-            } else {
-                info!("Event notifier initialized successfully");
-            }
-        });
-    } else {
-        info!("event_config is empty");
-    }
-}
-
 #[instrument(skip(opt))]
 async fn run(opt: config::Opt) -> Result<()> {
     debug!("opt: {:?}", &opt);
 
     // Initialize event notifier
-    let notifier_config = opt.event_config;
-    init_event_notifier(notifier_config).await;
+    event::init_event_notifier(opt.event_config).await;
 
     let server_addr = net::parse_and_resolve_address(opt.address.as_str())?;
     let server_port = server_addr.port();
@@ -147,16 +126,17 @@ async fn run(opt: config::Opt) -> Result<()> {
 
     debug!("server_address {}", &server_address);
 
-    //设置 AK 和 SK
+    // Set up AK and SK
     iam::init_global_action_cred(Some(opt.access_key.clone()), Some(opt.secret_key.clone()))?;
 
     set_global_rustfs_port(server_port);
 
-    //监听地址，端口从参数中获取
+    // The listening address and port are obtained from the parameters
     let listener = TcpListener::bind(server_address.clone()).await?;
-    //获取监听地址
+    // Obtain the listener address
     let local_addr: SocketAddr = listener.local_addr()?;
-    let local_ip = utils::get_local_ip().ok_or(local_addr.ip()).unwrap();
+    // let local_ip = utils::get_local_ip().ok_or(local_addr.ip()).unwrap();
+    let local_ip = rustfs_utils::get_local_ip().ok_or(local_addr.ip()).unwrap();
 
     // 用于 rpc
     let (endpoint_pools, setup_type) = EndpointServerPools::from_volumes(server_address.clone().as_str(), opt.volumes.clone())
@@ -203,13 +183,13 @@ async fn run(opt: config::Opt) -> Result<()> {
     set_global_endpoints(endpoint_pools.as_ref().clone());
     update_erasure_type(setup_type).await;
 
-    // 初始化本地磁盘
+    // Initialize the local disk
     init_local_disks(endpoint_pools.clone())
         .await
         .map_err(|err| Error::from_string(err.to_string()))?;
 
     // Setup S3 service
-    // 本项目使用 s3s 库来实现 s3 服务
+    // This project uses the S3S library to implement S3 services
     let s3_service = {
         let store = storage::ecfs::FS::new();
         // let mut b = S3ServiceBuilder::new(storage::ecfs::FS::new(server_address.clone(), endpoint_pools).await?);
@@ -217,7 +197,7 @@ async fn run(opt: config::Opt) -> Result<()> {
 
         let access_key = opt.access_key.clone();
         let secret_key = opt.secret_key.clone();
-        //显示 info 信息
+        // Displays info information
         debug!("authentication is enabled {}, {}", &access_key, &secret_key);
 
         b.set_auth(IAMAuth::new(access_key, secret_key));
@@ -268,7 +248,7 @@ async fn run(opt: config::Opt) -> Result<()> {
         debug!("Found TLS directory, checking for certificates");
 
         // 1. Try to load all certificates directly (including root and subdirectories)
-        match utils::load_all_certs_from_directory(&tls_path) {
+        match rustfs_utils::load_all_certs_from_directory(&tls_path) {
             Ok(cert_key_pairs) if !cert_key_pairs.is_empty() => {
                 debug!("Found {} certificates, starting with HTTPS", cert_key_pairs.len());
                 let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
@@ -276,7 +256,7 @@ async fn run(opt: config::Opt) -> Result<()> {
                 // create a multi certificate configuration
                 let mut server_config = ServerConfig::builder()
                     .with_no_client_auth()
-                    .with_cert_resolver(Arc::new(utils::create_multi_cert_resolver(cert_key_pairs)?));
+                    .with_cert_resolver(Arc::new(rustfs_utils::create_multi_cert_resolver(cert_key_pairs)?));
 
                 server_config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec(), b"http/1.0".to_vec()];
                 Some(TlsAcceptor::from(Arc::new(server_config)))
@@ -291,12 +271,14 @@ async fn run(opt: config::Opt) -> Result<()> {
                 if has_single_cert {
                     debug!("Found legacy single TLS certificate, starting with HTTPS");
                     let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
-                    let certs = utils::load_certs(cert_path.as_str()).map_err(|e| error(e.to_string()))?;
-                    let key = utils::load_private_key(key_path.as_str()).map_err(|e| error(e.to_string()))?;
+                    let certs =
+                        rustfs_utils::load_certs(cert_path.as_str()).map_err(|e| rustfs_utils::certs_error(e.to_string()))?;
+                    let key = rustfs_utils::load_private_key(key_path.as_str())
+                        .map_err(|e| rustfs_utils::certs_error(e.to_string()))?;
                     let mut server_config = ServerConfig::builder()
                         .with_no_client_auth()
                         .with_single_cert(certs, key)
-                        .map_err(|e| error(e.to_string()))?;
+                        .map_err(|e| rustfs_utils::certs_error(e.to_string()))?;
                     server_config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec(), b"http/1.0".to_vec()];
                     Some(TlsAcceptor::from(Arc::new(server_config)))
                 } else {
@@ -446,7 +428,7 @@ async fn run(opt: config::Opt) -> Result<()> {
                 debug!("TLS certificates found, starting with SIGINT");
                 let tls_socket = match tls_acceptor
                     .as_ref()
-                    .ok_or_else(|| error("TLS not configured".to_string()))
+                    .ok_or_else(|| rustfs_utils::certs_error("TLS not configured".to_string()))
                     .unwrap()
                     .accept(socket)
                     .await

rustfs/src/utils/certs.rs

@@ -1,180 +0,0 @@
-use crate::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(crate) fn load_certs(filename: &str) -> io::Result<Vec<CertificateDer<'static>>> {
-    // Open certificate file.
-    let cert_file = fs::File::open(filename).map_err(|e| 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(|_| error(format!("certificate file {} format error", filename)))?;
-    if certs.is_empty() {
-        return Err(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(crate) fn load_private_key(filename: &str) -> io::Result<PrivateKeyDer<'static>> {
-    // Open keyfile.
-    let keyfile = fs::File::open(filename).map_err(|e| 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(|| error(format!("no private key found in {}", filename)))
-}
-
-/// error function
-pub(crate) fn 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(crate) 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(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(|| error(format!("Invalid UTF-8 in root certificate path: {:?}", root_cert_path)))?;
-        let root_key_str = root_key_path
-            .to_str()
-            .ok_or_else(|| 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(|| 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(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(|_| 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| error(format!("failed to add a domain name certificate:{},err: {:?}", domain, e)))?;
-        }
-    }
-
-    Ok(MultiCertResolver {
-        cert_resolver: resolver,
-        default_cert,
-    })
-}

rustfs/src/utils/mod.rs

@@ -1,18 +0,0 @@
-mod certs;
-use std::net::IpAddr;
-
-pub(crate) use certs::create_multi_cert_resolver;
-pub(crate) use certs::error;
-pub(crate) use certs::load_all_certs_from_directory;
-pub(crate) use certs::load_certs;
-pub(crate) use certs::load_private_key;
-
-/// Get the local IP address.
-/// This function retrieves the local IP address of the machine.
-pub(crate) fn get_local_ip() -> Option<std::net::Ipv4Addr> {
-    match local_ip_address::local_ip() {
-        Ok(IpAddr::V4(ip)) => Some(ip),
-        Err(_) => None,
-        Ok(IpAddr::V6(_)) => todo!(),
-    }
-}