rec: janitor work on (generated) Rust code

pdns/recursordist/rec-rust-lib/cxxsupport.cc

@@ -546,7 +546,7 @@ static void processLine(const std::string& arg, FieldMap& map, bool mainFile)
   ::rust::String section;
   ::rust::String fieldname;
   ::rust::String type_name;
-  pdns::rust::settings::rec::Value rustvalue = {false, 0, 0.0, "", {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}};
+  pdns::rust::settings::rec::Value rustvalue = {false, 0, 0.0, "", {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}};
   if (pdns::settings::rec::oldKVToBridgeStruct(var, val, section, fieldname, type_name, rustvalue)) {
     auto overriding = !mainFile && !incremental && !simpleRustType(type_name);
     auto [existing, inserted] = map.emplace(std::pair{std::pair{section, fieldname}, pdns::rust::settings::rec::OldStyle{section, fieldname, var, std::move(type_name), rustvalue, overriding}});
@@ -671,6 +671,7 @@ std::string pdns::settings::rec::defaultsToYaml(bool postProcess)
   def("logging", "outgoing_protobuf_servers", "Vec<ProtobufServer>");
   def("logging", "dnstap_framestream_servers", "Vec<DNSTapFrameStreamServer>");
   def("logging", "dnstap_nod_framestream_servers", "Vec<DNSTapNODFrameStreamServer>");
+  def("logging", "opentelemetry_trace_conditions", "Vec<OpenTelemetryTraceCondition>");
   def("recursor", "rpzs", "Vec<RPZ>");
   def("recursor", "sortlists", "Vec<SortList>");
   def("recordcache", "zonetocaches", "Vec<ZoneToCache>");

pdns/recursordist/rec-rust-lib/generate.py

@@ -454,14 +454,14 @@ def gen_rust_vec_default_functions(name, typeName, defvalue):
     """Generate Rust code for the default handling of a vector for typeName"""
     ret = f"// DEFAULT HANDLING for {name}\n"
     ret += f"fn default_value_{name}() -> Vec<recsettings::{typeName}> {{\n"
-    ret += f'    let msg = "default value defined for `{name}\' should be valid YAML";'
+    ret += f'    let msg = "default value defined for `{name}\' should be valid YAML";\n'
     ret += (
         f"    let deserialized: Vec<recsettings::{typeName}> = serde_yaml::from_str({quote(defvalue)}).expect(msg);\n"
     )
     ret += f"    deserialized\n"
     ret += "}\n"
     ret += f"fn default_value_equal_{name}(value: &Vec<recsettings::{typeName}>)"
-    ret += "-> bool {\n"
+    ret += " -> bool {\n"
     ret += f"    let def = default_value_{name}();\n"
     ret += "    &def == value\n"
     ret += "}\n\n"
@@ -649,7 +649,10 @@ def gen_rust(srcdir, entries):
         with open(srcdir + "/rust-bridge-in.rs", mode="r", encoding="UTF-8") as bridge:
             file.write("    // START INCLUDE rust-bridge-in.rs\n")
             for line in bridge:
-                file.write("    " + line)
+                if len(line) <= 1:
+                    file.write(line)
+                else:
+                    file.write("    " + line)
 
         file.write("    // END INCLUDE rust-bridge-in.rs\n\n")
         for entry in entries:

pdns/recursordist/rec-rust-lib/rust-bridge-in.rs

@@ -405,6 +405,7 @@ struct Value {
     vec_forwardingcatalogzone_val: Vec<ForwardingCatalogZone>,
     vec_incomingwsconfig_val: Vec<IncomingWSConfig>,
     vec_outgoingtlsconfiguration_val: Vec<OutgoingTLSConfiguration>,
+    vec_opentelemetrytracecondition_val: Vec<OpenTelemetryTraceCondition>,
 }
 
 struct OldStyle {

pdns/recursordist/rec-rust-lib/rust/src/bridge.rs

@@ -850,6 +850,28 @@ impl OutgoingTLSConfiguration {
 }
 
 impl OpenTelemetryTraceCondition {
+    fn to_yaml_map(&self) -> serde_yaml::Value {
+        let mut map = serde_yaml::Mapping::new();
+        let mut acls = serde_yaml::Sequence::new();
+        for entry in &self.acls {
+            acls.push(serde_yaml::Value::String(entry.to_owned()));
+        }
+        insertseq(&mut map, "acls", &acls);
+        let mut qnames = serde_yaml::Sequence::new();
+        for entry in &self.qnames {
+            qnames.push(serde_yaml::Value::String(entry.to_owned()));
+        }
+        insertseq(&mut map, "qtypes", &qnames);
+        let mut qtypes = serde_yaml::Sequence::new();
+        for entry in &self.qtypes {
+            qtypes.push(serde_yaml::Value::String(entry.to_owned()));
+        }
+        insertseq(&mut map, "qtypes", &qtypes);
+        insertu32(&mut map, "qid", self.qid);
+        insertb(&mut map, "edns_option_required", self.edns_option_required);
+        insertb(&mut map, "traceid_only", self.traceid_only);
+        serde_yaml::Value::Mapping(map)
+    }
     pub fn validate(&self, field: &str) -> Result<(), ValidationError> {
         validate_vec(
             &(field.to_string() + ".acls"),
@@ -1211,6 +1233,13 @@ pub fn map_to_yaml_string(vec: &Vec<OldStyle>) -> Result<String, serde_yaml::Err
                         }
                         serde_yaml::Value::Sequence(seq)
                     }
+                    "Vec<OpenTelemetryTraceCondition>" => {
+                        let mut seq = serde_yaml::Sequence::new();
+                        for element in &entry.value.vec_opentelemetrytracecondition_val {
+                            seq.push(element.to_yaml_map());
+                        }
+                        serde_yaml::Value::Sequence(seq)
+                    }
                     other => serde_yaml::Value::String(
                         "map_to_yaml_string: Unknown type: ".to_owned() + other,
                     ),

pdns/recursordist/rec-rust-lib/rust/src/web.rs

@@ -463,7 +463,7 @@ fn collect_options(
     if !ctx.cross_origin_request_header.is_empty() {
         response.headers.push(rustweb::KeyValue {
             key: String::from("access-control-allow-origin"),
-            value: String::from(ctx.cross_origin_request_header.clone()),
+            value: ctx.cross_origin_request_header.clone(),
         });
     }