dnsdist: Apply Clippy's suggestions to our Rust code

Signed-off-by: Remi Gacogne <remi.gacogne@powerdns.com>

diff --git a/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py b/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py
index 6d430d7aaadce234f5d679e7070c0417f4a48b16..3152107ceee75532d8f9733aa712e177e5f7b43b 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py
+++ b/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py
@@ -568,7 +568,8 @@ def generate_cpp_selector_wrappers(def_dir, cxx_dest_dir):
 def generate_rust_actions_enum(output, def_dir, response):
     suffix = 'ResponseAction' if response else 'Action'
     actions_definitions = get_actions_definitions(def_dir, response)
-    enum_buffer = f'''#[derive(Default, Serialize, Deserialize, Debug, PartialEq)]
+    enum_buffer = f'''#[allow(clippy::upper_case_acronyms)]
+#[derive(Default, Serialize, Deserialize, Debug, PartialEq)]
 #[serde(tag = "type")]
 enum {suffix} {{
     #[default]
@@ -591,7 +592,8 @@ enum {suffix} {{
 def generate_rust_selectors_enum(output, def_dir):
     suffix = 'Selector'
     selectors_definitions = get_selectors_definitions(def_dir)
-    enum_buffer = f'''#[derive(Default, Serialize, Deserialize, Debug, PartialEq)]
+    enum_buffer = f'''#[allow(clippy::upper_case_acronyms)]
+#[derive(Default, Serialize, Deserialize, Debug, PartialEq)]
 #[serde(tag = "type")]
 enum {suffix} {{
     #[default]
@@ -663,8 +665,10 @@ def generate_rust_action_to_config(output, def_dir, response):
         name = get_rust_object_name(action['name'])
         if name in ['Continue']:
             enum_buffer += f'''        {suffix}::{name}(cont) => {{
-             let mut config: dnsdistsettings::{name}{suffix}Configuration = Default::default();
-             config.action = get_one_action_from_serde(&*cont.action)?;
+             let config = dnsdistsettings::{name}{suffix}Configuration {{
+                 action: get_one_action_from_serde(&cont.action)?,
+                 ..Default::default()
+             }};
              return Ok(dnsdistsettings::SharedDNS{suffix} {{
                  action: dnsdistsettings::get{name}{suffix}(&config)?,
              }});
@@ -673,7 +677,7 @@ def generate_rust_action_to_config(output, def_dir, response):
         else:
             enum_buffer += f'''        {suffix}::{name}(config) => {{
                 return Ok(dnsdistsettings::SharedDNS{suffix} {{
-                    action: dnsdistsettings::get{name}{suffix}(&config)?,
+                    action: dnsdistsettings::get{name}{suffix}(config)?,
                 }});
             }}
 '''
@@ -701,7 +705,7 @@ def generate_rust_selector_to_config(output, def_dir):
             enum_buffer += f'''        {suffix}::{name}({var}) => {{
              let mut config: dnsdistsettings::{name}{suffix}Configuration = Default::default();
              for sub_selector in &{var}.selectors {{
-                 config.selectors.push(get_one_selector_from_serde(&sub_selector)?)
+                 config.selectors.push(get_one_selector_from_serde(sub_selector)?)
              }}
              return Ok(dnsdistsettings::SharedDNS{suffix} {{
                        selector: dnsdistsettings::get{name}{suffix}(&config)?
@@ -711,7 +715,7 @@ def generate_rust_selector_to_config(output, def_dir):
         elif name in ['Not']:
             enum_buffer += f'''        {suffix}::{name}({var}) => {{
              let mut config: dnsdistsettings::{name}{suffix}Configuration = Default::default();
-             match get_one_selector_from_serde(&*{var}.selector) {{
+             match get_one_selector_from_serde(&{var}.selector) {{
                  Ok(sel) => config.selector = sel,
                  Err(e) => return Err(e),
              }}
@@ -725,7 +729,7 @@ def generate_rust_selector_to_config(output, def_dir):
 '''
         else:
             enum_buffer += f'''        {suffix}::{name}({var}) => {{
-            match dnsdistsettings::get{name}{suffix}(&{var}) {{
+            match dnsdistsettings::get{name}{suffix}({var}) {{
                 Ok(sel) => return Ok(dnsdistsettings::SharedDNS{suffix} {{
                                   selector: sel,
                            }}),

diff --git a/pdns/dnsdistdist/dnsdist-rust-lib/rust-post-in.rs b/pdns/dnsdistdist/dnsdist-rust-lib/rust-post-in.rs
index 796284a8f0b13c2a7ee85b676d1b9167ff524ef2..091441c408e8f0aed78cfbdf20d255a1fb63d2e0 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-rust-lib/rust-post-in.rs
+++ b/pdns/dnsdistdist/dnsdist-rust-lib/rust-post-in.rs
@@ -4,7 +4,7 @@ fn get_selectors_from_serde(
     let mut results: Vec<dnsdistsettings::SharedDNSSelector> = Vec::new();
 
     for rule in selectors_from_serde {
-        results.push(get_one_selector_from_serde(&rule)?)
+        results.push(get_one_selector_from_serde(rule)?)
     }
     Ok(results)
 }
@@ -20,8 +20,8 @@ fn get_query_rules_from_serde(
         results.push(dnsdistsettings::QueryRuleConfiguration {
             name: rule.name.clone(),
             uuid: rule.uuid.clone(),
-            selector: selector,
-            action: action,
+            selector,
+            action,
         });
     }
     Ok(results)
@@ -38,8 +38,8 @@ fn get_response_rules_from_serde(
         results.push(dnsdistsettings::ResponseRuleConfiguration {
             name: rule.name.clone(),
             uuid: rule.uuid.clone(),
-            selector: selector,
-            action: action,
+            selector,
+            action,
         });
     }
     Ok(results)
@@ -49,44 +49,46 @@ fn register_remote_loggers(
   config: &dnsdistsettings::RemoteLoggingConfiguration,
 ) {
   for logger in &config.protobuf_loggers {
-    dnsdistsettings::registerProtobufLogger(&logger);
+    dnsdistsettings::registerProtobufLogger(logger);
   }
   for logger in &config.dnstap_loggers {
-    dnsdistsettings::registerDnstapLogger(&logger);
+    dnsdistsettings::registerDnstapLogger(logger);
   }
 }
 
 fn get_global_configuration_from_serde(
     serde: GlobalConfigurationSerde,
 ) -> Result<dnsdistsettings::GlobalConfiguration, cxx::Exception> {
-    let mut config: dnsdistsettings::GlobalConfiguration = Default::default();
-    config.acl = serde.acl;
-    config.backends = serde.backends;
-    config.binds = serde.binds;
-    config.cache_settings = serde.cache_settings;
-    config.console = serde.console;
-    config.dynamic_rules = serde.dynamic_rules;
-    config.dynamic_rules_settings = serde.dynamic_rules_settings;
-    config.ebpf = serde.ebpf;
-    config.edns_client_subnet = serde.edns_client_subnet;
-    config.general = serde.general;
-    config.key_value_stores = serde.key_value_stores;
-    config.load_balancing_policies = serde.load_balancing_policies;
-    config.logging = serde.logging;
-    config.metrics = serde.metrics;
-    config.netmask_groups = serde.netmask_groups;
-    config.packet_caches = serde.packet_caches;
-    config.pools = serde.pools;
-    config.proxy_protocol = serde.proxy_protocol;
-    config.query_count = serde.query_count;
-    config.remote_logging = serde.remote_logging;
-    config.ring_buffers = serde.ring_buffers;
-    config.security_polling = serde.security_polling;
-    config.snmp = serde.snmp;
-    config.timed_ip_sets = serde.timed_ip_sets;
-    config.tuning = serde.tuning;
-    config.webserver = serde.webserver;
-    config.xsk = serde.xsk;
+    let mut config = dnsdistsettings::GlobalConfiguration {
+        acl: serde.acl,
+        backends: serde.backends,
+        binds: serde.binds,
+        cache_settings: serde.cache_settings,
+        console: serde.console,
+        dynamic_rules: serde.dynamic_rules,
+        dynamic_rules_settings: serde.dynamic_rules_settings,
+        ebpf: serde.ebpf,
+        edns_client_subnet: serde.edns_client_subnet,
+        general: serde.general,
+        key_value_stores: serde.key_value_stores,
+        load_balancing_policies: serde.load_balancing_policies,
+        logging: serde.logging,
+        metrics: serde.metrics,
+        netmask_groups: serde.netmask_groups,
+        packet_caches: serde.packet_caches,
+        pools: serde.pools,
+        proxy_protocol: serde.proxy_protocol,
+        query_count: serde.query_count,
+        remote_logging: serde.remote_logging,
+        ring_buffers: serde.ring_buffers,
+        security_polling: serde.security_polling,
+        snmp: serde.snmp,
+        timed_ip_sets: serde.timed_ip_sets,
+        tuning: serde.tuning,
+        webserver: serde.webserver,
+        xsk: serde.xsk,
+        ..Default::default()
+    };
     // this needs to be done before the rules so that they can refer to the loggers
     register_remote_loggers(&config.remote_logging);
     // this needs to be done before the rules so that they can refer to the KVS objects
@@ -116,15 +118,15 @@ pub fn from_yaml_string(
         serde_yaml::from_str(str);
 
     if let Err(e) = serde_config {
-      return Err(e.to_string().into());
+      return Err(e.to_string());
     }
     let serde_config = serde_config.unwrap();
     let validation_result = serde_config.validate();
     if let Err(e) = validation_result {
-      return Err(e.to_string().into())
+      return Err(e.to_string())
     }
     match get_global_configuration_from_serde(serde_config) {
-      Ok(config) => return Ok(config),
-      Err(e) => return Err(e.to_string().into()),
+      Ok(config) => Ok(config),
+      Err(e) => Err(e.to_string()),
     }
 }

diff --git a/pdns/dnsdistdist/dnsdist-rust-lib/rust/build.rs b/pdns/dnsdistdist/dnsdist-rust-lib/rust/build.rs
index 26bdbc13c10326f5743441ebbbe49445dc384bfd..3996d92fdb6b68400f938f42ae2c13c919ef98ad 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-rust-lib/rust/build.rs
+++ b/pdns/dnsdistdist/dnsdist-rust-lib/rust/build.rs
@@ -11,8 +11,8 @@ fn main() {
             .flag("-I..")
             .flag("-I../..");
     let generated_headers_dir_env = env::var("generatedheadersdir");
-    if generated_headers_dir_env.is_ok() {
-      let generated_headers_dir = PathBuf::from(generated_headers_dir_env.unwrap());
+    if let Ok(dir) = generated_headers_dir_env {
+      let generated_headers_dir = PathBuf::from(dir);
       let generated_headers_dir_canon = fs::canonicalize(&generated_headers_dir);
       if generated_headers_dir_canon.is_ok() {
         build = build.flag(format!("-I{}", generated_headers_dir_canon.unwrap().display()))