chore: upgrade dependencies and migrate to aws-lc-rs (#1333)

crates/notify/src/factory.rs

@@ -204,10 +204,10 @@ impl TargetFactory for MQTTTargetFactory {
             if !std::path::Path::new(&queue_dir).is_absolute() {
                 return Err(TargetError::Configuration("MQTT queue directory must be an absolute path".to_string()));
             }
-            if let Some(qos_str) = config.lookup(MQTT_QOS) {
-                if qos_str == "0" {
-                    warn!("Using queue_dir with QoS 0 may result in event loss");
-                }
+            if let Some(qos_str) = config.lookup(MQTT_QOS)
+                && qos_str == "0"
+            {
+                warn!("Using queue_dir with QoS 0 may result in event loss");
             }
         }
 

crates/notify/src/notifier.rs

@@ -345,10 +345,10 @@ impl TargetList {
     pub async fn clear_targets_only(&mut self) {
         let target_ids_to_clear: Vec<TargetID> = self.targets.keys().cloned().collect();
         for id in target_ids_to_clear {
-            if let Some(target_arc) = self.targets.remove(&id) {
-                if let Err(e) = target_arc.close().await {
-                    error!("Failed to close target {} during clear: {}", id, e);
-                }
+            if let Some(target_arc) = self.targets.remove(&id)
+                && let Err(e) = target_arc.close().await
+            {
+                error!("Failed to close target {} during clear: {}", id, e);
             }
         }
         self.targets.clear();

crates/notify/src/registry.rs

@@ -119,12 +119,11 @@ impl TargetRegistry {
                 format!("{ENV_PREFIX}{NOTIFY_ROUTE_PREFIX}{target_type}{DEFAULT_DELIMITER}{ENABLE_KEY}{DEFAULT_DELIMITER}")
                     .to_uppercase();
             for (key, value) in &all_env {
-                if EnableState::from_str(value).ok().map(|s| s.is_enabled()).unwrap_or(false) {
-                    if let Some(id) = key.strip_prefix(&enable_prefix) {
-                        if !id.is_empty() {
-                            instance_ids_from_env.insert(id.to_lowercase());
-                        }
-                    }
+                if EnableState::from_str(value).ok().map(|s| s.is_enabled()).unwrap_or(false)
+                    && let Some(id) = key.strip_prefix(&enable_prefix)
+                    && !id.is_empty()
+                {
+                    instance_ids_from_env.insert(id.to_lowercase());
                 }
             }
 
@@ -273,10 +272,10 @@ impl TargetRegistry {
             for section in sections {
                 let mut section_map: std::collections::HashMap<String, KVS> = std::collections::HashMap::new();
                 // Add default item
-                if let Some(default_kvs) = section_defaults.get(&section) {
-                    if !default_kvs.is_empty() {
-                        section_map.insert(DEFAULT_DELIMITER.to_string(), default_kvs.clone());
-                    }
+                if let Some(default_kvs) = section_defaults.get(&section)
+                    && !default_kvs.is_empty()
+                {
+                    section_map.insert(DEFAULT_DELIMITER.to_string(), default_kvs.clone());
                 }
 
                 // Add successful instance item

crates/notify/src/rules/pattern.rs

@@ -24,30 +24,30 @@ pub fn new_pattern(prefix: Option<&str>, suffix: Option<&str>) -> String {
     let mut pattern = String::new();
 
     // Process the prefix part
-    if let Some(p) = prefix {
-        if !p.is_empty() {
-            pattern.push_str(p);
-            if !p.ends_with('*') {
-                pattern.push('*');
-            }
+    if let Some(p) = prefix
+        && !p.is_empty()
+    {
+        pattern.push_str(p);
+        if !p.ends_with('*') {
+            pattern.push('*');
         }
     }
 
     // Process the suffix part
-    if let Some(s) = suffix {
-        if !s.is_empty() {
-            let mut s_to_append = s.to_string();
-            if !s.starts_with('*') {
-                s_to_append.insert(0, '*');
-            }
+    if let Some(s) = suffix
+        && !s.is_empty()
+    {
+        let mut s_to_append = s.to_string();
+        if !s.starts_with('*') {
+            s_to_append.insert(0, '*');
+        }
 
-            // If the pattern is empty (only suffixes are provided), then the pattern is the suffix
-            // Otherwise, append the suffix to the pattern
-            if pattern.is_empty() {
-                pattern = s_to_append;
-            } else {
-                pattern.push_str(&s_to_append);
-            }
+        // If the pattern is empty (only suffixes are provided), then the pattern is the suffix
+        // Otherwise, append the suffix to the pattern
+        if pattern.is_empty() {
+            pattern = s_to_append;
+        } else {
+            pattern.push_str(&s_to_append);
         }
     }