Fix KMS configuration synchronization across cluster nodes (#855)

* Initial plan

* Add KMS configuration persistence to cluster storage

Co-authored-by: houseme <4829346+houseme@users.noreply.github.com>

* Apply code formatting to KMS configuration changes

Co-authored-by: houseme <4829346+houseme@users.noreply.github.com>

* add comment

* fix fmt

* fix

* Fix overlapping dependabot cargo configurations

Co-authored-by: houseme <4829346+houseme@users.noreply.github.com>

* improve code for comment and replace  `Once_Cell` to `std::sync::OnceLock`

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: houseme <4829346+houseme@users.noreply.github.com>
Co-authored-by: houseme <housemecn@gmail.com>
Co-authored-by: loverustfs <155562731+loverustfs@users.noreply.github.com>

crates/utils/src/notify/net.rs

@@ -40,7 +40,8 @@ pub enum NetError {
     SchemeWithEmptyHost,
 }
 
-// Host represents a network host with IP/name and port.
+/// Host represents a network host with IP/name and port.
+/// Similar to Go's net.Host structure.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Host {
     pub name: String,
@@ -130,22 +131,38 @@ fn trim_ipv6(host: &str) -> Result<String, NetError> {
     }
 }
 
-// URL is a wrapper around url::Url for custom handling.
+/// URL is a wrapper around url::Url for custom handling.
+/// Provides methods similar to Go's URL struct.
 #[derive(Debug, Clone)]
 pub struct ParsedURL(pub Url);
 
 impl ParsedURL {
     /// is_empty returns true if the URL is empty or "about:blank".
+    ///
+    /// # Arguments
+    /// * `&self` - Reference to the ParsedURL instance.
+    ///
+    /// # Returns
+    /// * `bool` - True if the URL is empty or "about:blank", false otherwise.
+    ///
     pub fn is_empty(&self) -> bool {
         self.0.as_str() == "" || (self.0.scheme() == "about" && self.0.path() == "blank")
     }
 
     /// hostname returns the hostname of the URL.
+    ///
+    /// # Returns
+    /// * `String` - The hostname of the URL, or an empty string if not set.
+    ///
     pub fn hostname(&self) -> String {
         self.0.host_str().unwrap_or("").to_string()
     }
 
     /// port returns the port of the URL as a string, defaulting to "80" for http and "443" for https if not set.
+    ///
+    /// # Returns
+    /// * `String` - The port of the URL as a string.
+    ///
     pub fn port(&self) -> String {
         match self.0.port() {
             Some(p) => p.to_string(),
@@ -158,11 +175,19 @@ impl ParsedURL {
     }
 
     /// scheme returns the scheme of the URL.
+    ///
+    /// # Returns
+    /// * `&str` - The scheme of the URL.
+    ///
     pub fn scheme(&self) -> &str {
         self.0.scheme()
     }
 
     /// url returns a reference to the underlying Url.
+    ///
+    /// # Returns
+    /// * `&Url` - Reference to the underlying Url.
+    ///
     pub fn url(&self) -> &Url {
         &self.0
     }
@@ -213,7 +238,18 @@ impl<'de> serde::Deserialize<'de> for ParsedURL {
     }
 }
 
-// parse_url parses a string into a ParsedURL, with host validation and path cleaning.
+/// parse_url parses a string into a ParsedURL, with host validation and path cleaning.
+///
+/// # Arguments
+/// * `s` - The URL string to parse.
+///
+/// # Returns
+/// * `Ok(ParsedURL)` - If parsing is successful.
+/// * `Err(NetError)` - If parsing fails or host is invalid.
+///
+/// # Errors
+/// Returns NetError if parsing fails or host is invalid.
+///
 pub fn parse_url(s: &str) -> Result<ParsedURL, NetError> {
     if let Some(scheme_end) = s.find("://") {
         if s[scheme_end + 3..].starts_with('/') {
@@ -273,6 +309,14 @@ pub fn parse_url(s: &str) -> Result<ParsedURL, NetError> {
 
 #[allow(dead_code)]
 /// parse_http_url parses a string into a ParsedURL, ensuring the scheme is http or https.
+///
+/// # Arguments
+/// * `s` - The URL string to parse.
+///
+/// # Returns
+/// * `Ok(ParsedURL)` - If parsing is successful and scheme is http/https.
+/// * `Err(NetError)` - If parsing fails or scheme is not http/https.
+///
 pub fn parse_http_url(s: &str) -> Result<ParsedURL, NetError> {
     let u = parse_url(s)?;
     match u.0.scheme() {
@@ -283,6 +327,14 @@ pub fn parse_http_url(s: &str) -> Result<ParsedURL, NetError> {
 
 #[allow(dead_code)]
 /// is_network_or_host_down checks if an error indicates network or host down, considering timeouts.
+///
+/// # Arguments
+/// * `err` - The std::io::Error to check.
+/// * `expect_timeouts` - Whether timeouts are expected.
+///
+/// # Returns
+/// * `bool` - True if the error indicates network or host down, false otherwise.
+///
 pub fn is_network_or_host_down(err: &std::io::Error, expect_timeouts: bool) -> bool {
     if err.kind() == std::io::ErrorKind::TimedOut {
         return !expect_timeouts;
@@ -297,12 +349,26 @@ pub fn is_network_or_host_down(err: &std::io::Error, expect_timeouts: bool) -> b
 
 #[allow(dead_code)]
 /// is_conn_reset_err checks if an error indicates a connection reset by peer.
+///
+/// # Arguments
+/// * `err` - The std::io::Error to check.
+///
+/// # Returns
+/// * `bool` - True if the error indicates connection reset, false otherwise.
+///
 pub fn is_conn_reset_err(err: &std::io::Error) -> bool {
     err.to_string().contains("connection reset by peer") || matches!(err.raw_os_error(), Some(libc::ECONNRESET))
 }
 
 #[allow(dead_code)]
 /// is_conn_refused_err checks if an error indicates a connection refused.
+///
+/// # Arguments
+/// * `err` - The std::io::Error to check.
+///
+/// # Returns
+/// * `bool` - True if the error indicates connection refused, false otherwise.
+///
 pub fn is_conn_refused_err(err: &std::io::Error) -> bool {
     err.to_string().contains("connection refused") || matches!(err.raw_os_error(), Some(libc::ECONNREFUSED))
 }