dnsdist: Simplify the handle of flat settings from YAML

As suggested by Otto (thanks!)

diff --git a/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-configuration-yaml-items-generated.cc b/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-configuration-yaml-items-generated.cc
index 697ee5bc85d5b8c67d3996a9d8a580851385eb6a..020f705c86739b6b61a70369e51a4b55da4a7cae 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-configuration-yaml-items-generated.cc
+++ b/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-configuration-yaml-items-generated.cc
@@ -34,187 +34,187 @@ namespace dnsdist::configuration::yaml
 {
 void convertRuntimeFlatSettingsFromRust(const dnsdist::rust::settings::GlobalConfiguration& yamlConfig, dnsdist::configuration::RuntimeConfiguration& config)
 {
-  if (yamlConfig.console.maximum_output_size != 10000000 && config.d_consoleOutputMsgMaxSize == 10000000) {
+  if (config.d_consoleOutputMsgMaxSize == 10000000) {
     config.d_consoleOutputMsgMaxSize = yamlConfig.console.maximum_output_size;
   }
-  if (yamlConfig.console.log_connections != true && config.d_logConsoleConnections == true) {
+  if (config.d_logConsoleConnections == true) {
     config.d_logConsoleConnections = yamlConfig.console.log_connections;
   }
-  if (yamlConfig.edns_client_subnet.override_existing != false && config.d_ecsOverride == false) {
+  if (config.d_ecsOverride == false) {
     config.d_ecsOverride = yamlConfig.edns_client_subnet.override_existing;
   }
-  if (yamlConfig.edns_client_subnet.source_prefix_v4 != 32 && config.d_ECSSourcePrefixV4 == 32) {
+  if (config.d_ECSSourcePrefixV4 == 32) {
     config.d_ECSSourcePrefixV4 = yamlConfig.edns_client_subnet.source_prefix_v4;
   }
-  if (yamlConfig.edns_client_subnet.source_prefix_v6 != 56 && config.d_ECSSourcePrefixV6 == 56) {
+  if (config.d_ECSSourcePrefixV6 == 56) {
     config.d_ECSSourcePrefixV6 = yamlConfig.edns_client_subnet.source_prefix_v6;
   }
-  if (yamlConfig.dynamic_rules_settings.purge_interval != 60 && config.d_dynBlocksPurgeInterval == 60) {
+  if (config.d_dynBlocksPurgeInterval == 60) {
     config.d_dynBlocksPurgeInterval = yamlConfig.dynamic_rules_settings.purge_interval;
   }
-  if (yamlConfig.tuning.tcp.receive_timeout != 2 && config.d_tcpRecvTimeout == 2) {
+  if (config.d_tcpRecvTimeout == 2) {
     config.d_tcpRecvTimeout = yamlConfig.tuning.tcp.receive_timeout;
   }
-  if (yamlConfig.tuning.tcp.send_timeout != 2 && config.d_tcpSendTimeout == 2) {
+  if (config.d_tcpSendTimeout == 2) {
     config.d_tcpSendTimeout = yamlConfig.tuning.tcp.send_timeout;
   }
-  if (yamlConfig.tuning.tcp.max_queries_per_connection != 0 && config.d_maxTCPQueriesPerConn == 0) {
+  if (config.d_maxTCPQueriesPerConn == 0) {
     config.d_maxTCPQueriesPerConn = yamlConfig.tuning.tcp.max_queries_per_connection;
   }
-  if (yamlConfig.tuning.tcp.max_connection_duration != 0 && config.d_maxTCPConnectionDuration == 0) {
+  if (config.d_maxTCPConnectionDuration == 0) {
     config.d_maxTCPConnectionDuration = yamlConfig.tuning.tcp.max_connection_duration;
   }
-  if (yamlConfig.tuning.tls.outgoing_tickets_cache_cleanup_delay != 60 && config.d_tlsSessionCacheCleanupDelay == 60) {
+  if (config.d_tlsSessionCacheCleanupDelay == 60) {
     config.d_tlsSessionCacheCleanupDelay = yamlConfig.tuning.tls.outgoing_tickets_cache_cleanup_delay;
   }
-  if (yamlConfig.tuning.tls.outgoing_tickets_cache_validity != 600 && config.d_tlsSessionCacheSessionValidity == 600) {
+  if (config.d_tlsSessionCacheSessionValidity == 600) {
     config.d_tlsSessionCacheSessionValidity = yamlConfig.tuning.tls.outgoing_tickets_cache_validity;
   }
-  if (yamlConfig.tuning.tls.max_outgoing_tickets_per_backend != 20 && config.d_tlsSessionCacheMaxSessionsPerBackend == 20) {
+  if (config.d_tlsSessionCacheMaxSessionsPerBackend == 20) {
     config.d_tlsSessionCacheMaxSessionsPerBackend = yamlConfig.tuning.tls.max_outgoing_tickets_per_backend;
   }
-  if (yamlConfig.cache_settings.stale_entries_ttl != 0 && config.d_staleCacheEntriesTTL == 0) {
+  if (config.d_staleCacheEntriesTTL == 0) {
     config.d_staleCacheEntriesTTL = yamlConfig.cache_settings.stale_entries_ttl;
   }
-  if (yamlConfig.cache_settings.cleaning_delay != 60 && config.d_cacheCleaningDelay == 60) {
+  if (config.d_cacheCleaningDelay == 60) {
     config.d_cacheCleaningDelay = yamlConfig.cache_settings.cleaning_delay;
   }
-  if (yamlConfig.cache_settings.cleaning_percentage != 100 && config.d_cacheCleaningPercentage == 100) {
+  if (config.d_cacheCleaningPercentage == 100) {
     config.d_cacheCleaningPercentage = yamlConfig.cache_settings.cleaning_percentage;
   }
-  if (yamlConfig.security_polling.polling_interval != 3600 && config.d_secPollInterval == 3600) {
+  if (config.d_secPollInterval == 3600) {
     config.d_secPollInterval = yamlConfig.security_polling.polling_interval;
   }
-  if (yamlConfig.security_polling.suffix != "secpoll.powerdns.com." && config.d_secPollSuffix == "secpoll.powerdns.com.") {
+  if (config.d_secPollSuffix == "secpoll.powerdns.com.") {
     config.d_secPollSuffix = std::string(yamlConfig.security_polling.suffix);
   }
-  if (yamlConfig.general.edns_udp_payload_size_self_generated_answers != 1232 && config.d_payloadSizeSelfGenAnswers == 1232) {
+  if (config.d_payloadSizeSelfGenAnswers == 1232) {
     config.d_payloadSizeSelfGenAnswers = yamlConfig.general.edns_udp_payload_size_self_generated_answers;
   }
-  if (yamlConfig.general.add_edns_to_self_generated_answers != true && config.d_addEDNSToSelfGeneratedResponses == true) {
+  if (config.d_addEDNSToSelfGeneratedResponses == true) {
     config.d_addEDNSToSelfGeneratedResponses = yamlConfig.general.add_edns_to_self_generated_answers;
   }
-  if (yamlConfig.general.truncate_tc_answers != false && config.d_truncateTC == false) {
+  if (config.d_truncateTC == false) {
     config.d_truncateTC = yamlConfig.general.truncate_tc_answers;
   }
-  if (yamlConfig.general.fixup_case != false && config.d_fixupCase == false) {
+  if (config.d_fixupCase == false) {
     config.d_fixupCase = yamlConfig.general.fixup_case;
   }
-  if (yamlConfig.general.verbose != false && config.d_verbose == false) {
+  if (config.d_verbose == false) {
     config.d_verbose = yamlConfig.general.verbose;
   }
-  if (yamlConfig.general.verbose_health_checks != false && config.d_verboseHealthChecks == false) {
+  if (config.d_verboseHealthChecks == false) {
     config.d_verboseHealthChecks = yamlConfig.general.verbose_health_checks;
   }
-  if (yamlConfig.general.allow_empty_responses != false && config.d_allowEmptyResponse == false) {
+  if (config.d_allowEmptyResponse == false) {
     config.d_allowEmptyResponse = yamlConfig.general.allow_empty_responses;
   }
-  if (yamlConfig.general.drop_empty_queries != false && config.d_dropEmptyQueries == false) {
+  if (config.d_dropEmptyQueries == false) {
     config.d_dropEmptyQueries = yamlConfig.general.drop_empty_queries;
   }
-  if (yamlConfig.proxy_protocol.maximum_payload_size != 512 && config.d_proxyProtocolMaximumSize == 512) {
+  if (config.d_proxyProtocolMaximumSize == 512) {
     config.d_proxyProtocolMaximumSize = yamlConfig.proxy_protocol.maximum_payload_size;
   }
-  if (yamlConfig.proxy_protocol.apply_acl_to_proxied_clients != false && config.d_applyACLToProxiedClients == false) {
+  if (config.d_applyACLToProxiedClients == false) {
     config.d_applyACLToProxiedClients = yamlConfig.proxy_protocol.apply_acl_to_proxied_clients;
   }
-  if (yamlConfig.load_balancing_policies.servfail_on_no_server != false && config.d_servFailOnNoPolicy == false) {
+  if (config.d_servFailOnNoPolicy == false) {
     config.d_servFailOnNoPolicy = yamlConfig.load_balancing_policies.servfail_on_no_server;
   }
-  if (yamlConfig.load_balancing_policies.round_robin_servfail_on_no_server != false && config.d_roundrobinFailOnNoServer == false) {
+  if (config.d_roundrobinFailOnNoServer == false) {
     config.d_roundrobinFailOnNoServer = yamlConfig.load_balancing_policies.round_robin_servfail_on_no_server;
   }
 }
 void convertImmutableFlatSettingsFromRust(const dnsdist::rust::settings::GlobalConfiguration& yamlConfig, dnsdist::configuration::ImmutableConfiguration& config)
 {
-  if (yamlConfig.console.max_concurrent_connections != 0 && config.d_consoleMaxConcurrentConnections == 0) {
+  if (config.d_consoleMaxConcurrentConnections == 0) {
     config.d_consoleMaxConcurrentConnections = yamlConfig.console.max_concurrent_connections;
   }
-  if (yamlConfig.ring_buffers.size != 10000 && config.d_ringsCapacity == 10000) {
+  if (config.d_ringsCapacity == 10000) {
     config.d_ringsCapacity = yamlConfig.ring_buffers.size;
   }
-  if (yamlConfig.ring_buffers.shards != 10 && config.d_ringsNumberOfShards == 10) {
+  if (config.d_ringsNumberOfShards == 10) {
     config.d_ringsNumberOfShards = yamlConfig.ring_buffers.shards;
   }
-  if (yamlConfig.ring_buffers.lock_retries != 5 && config.d_ringsNbLockTries == 5) {
+  if (config.d_ringsNbLockTries == 5) {
     config.d_ringsNbLockTries = yamlConfig.ring_buffers.lock_retries;
   }
-  if (yamlConfig.ring_buffers.record_queries != true && config.d_ringsRecordQueries == true) {
+  if (config.d_ringsRecordQueries == true) {
     config.d_ringsRecordQueries = yamlConfig.ring_buffers.record_queries;
   }
-  if (yamlConfig.ring_buffers.record_responses != true && config.d_ringsRecordResponses == true) {
+  if (config.d_ringsRecordResponses == true) {
     config.d_ringsRecordResponses = yamlConfig.ring_buffers.record_responses;
   }
-  if (yamlConfig.tuning.tcp.worker_threads != 10 && config.d_maxTCPClientThreads == 10) {
+  if (config.d_maxTCPClientThreads == 10) {
     config.d_maxTCPClientThreads = yamlConfig.tuning.tcp.worker_threads;
   }
-  if (yamlConfig.tuning.tcp.max_queued_connections != 10000 && config.d_maxTCPQueuedConnections == 10000) {
+  if (config.d_maxTCPQueuedConnections == 10000) {
     config.d_maxTCPQueuedConnections = yamlConfig.tuning.tcp.max_queued_connections;
   }
-  if (yamlConfig.tuning.tcp.internal_pipe_buffer_size != 1048576 && config.d_tcpInternalPipeBufferSize == 1048576) {
+  if (config.d_tcpInternalPipeBufferSize == 1048576) {
     config.d_tcpInternalPipeBufferSize = yamlConfig.tuning.tcp.internal_pipe_buffer_size;
   }
-  if (yamlConfig.tuning.tcp.outgoing_max_idle_time != 300 && config.d_outgoingTCPMaxIdleTime == 300) {
+  if (config.d_outgoingTCPMaxIdleTime == 300) {
     config.d_outgoingTCPMaxIdleTime = yamlConfig.tuning.tcp.outgoing_max_idle_time;
   }
-  if (yamlConfig.tuning.tcp.outgoing_cleanup_interval != 60 && config.d_outgoingTCPCleanupInterval == 60) {
+  if (config.d_outgoingTCPCleanupInterval == 60) {
     config.d_outgoingTCPCleanupInterval = yamlConfig.tuning.tcp.outgoing_cleanup_interval;
   }
-  if (yamlConfig.tuning.tcp.outgoing_max_idle_connection_per_backend != 10 && config.d_outgoingTCPMaxIdlePerBackend == 10) {
+  if (config.d_outgoingTCPMaxIdlePerBackend == 10) {
     config.d_outgoingTCPMaxIdlePerBackend = yamlConfig.tuning.tcp.outgoing_max_idle_connection_per_backend;
   }
-  if (yamlConfig.tuning.tcp.max_connections_per_client != 0 && config.d_maxTCPConnectionsPerClient == 0) {
+  if (config.d_maxTCPConnectionsPerClient == 0) {
     config.d_maxTCPConnectionsPerClient = yamlConfig.tuning.tcp.max_connections_per_client;
   }
-  if (yamlConfig.tuning.udp.messages_per_round != 1 && config.d_udpVectorSize == 1) {
+  if (config.d_udpVectorSize == 1) {
     config.d_udpVectorSize = yamlConfig.tuning.udp.messages_per_round;
   }
-  if (yamlConfig.tuning.udp.send_buffer_size != 0 && config.d_socketUDPSendBuffer == 0) {
+  if (config.d_socketUDPSendBuffer == 0) {
     config.d_socketUDPSendBuffer = yamlConfig.tuning.udp.send_buffer_size;
   }
-  if (yamlConfig.tuning.udp.receive_buffer_size != 0 && config.d_socketUDPRecvBuffer == 0) {
+  if (config.d_socketUDPRecvBuffer == 0) {
     config.d_socketUDPRecvBuffer = yamlConfig.tuning.udp.receive_buffer_size;
   }
-  if (yamlConfig.tuning.udp.max_outstanding_per_backend != 65535 && config.d_maxUDPOutstanding == 65535) {
+  if (config.d_maxUDPOutstanding == 65535) {
     config.d_maxUDPOutstanding = yamlConfig.tuning.udp.max_outstanding_per_backend;
   }
-  if (yamlConfig.tuning.udp.timeout != 2 && config.d_udpTimeout == 2) {
+  if (config.d_udpTimeout == 2) {
     config.d_udpTimeout = yamlConfig.tuning.udp.timeout;
   }
-  if (yamlConfig.tuning.udp.randomize_outgoing_sockets_to_backend != false && config.d_randomizeUDPSocketsToBackend == false) {
+  if (config.d_randomizeUDPSocketsToBackend == false) {
     config.d_randomizeUDPSocketsToBackend = yamlConfig.tuning.udp.randomize_outgoing_sockets_to_backend;
   }
-  if (yamlConfig.tuning.udp.randomize_ids_to_backend != false && config.d_randomizeIDsToBackend == false) {
+  if (config.d_randomizeIDsToBackend == false) {
     config.d_randomizeIDsToBackend = yamlConfig.tuning.udp.randomize_ids_to_backend;
   }
-  if (yamlConfig.tuning.doh.outgoing_worker_threads != 10 && config.d_outgoingDoHWorkers == 10) {
+  if (config.d_outgoingDoHWorkers == 10) {
     config.d_outgoingDoHWorkers = yamlConfig.tuning.doh.outgoing_worker_threads;
   }
-  if (yamlConfig.tuning.doh.outgoing_max_idle_time != 300 && config.d_outgoingDoHMaxIdleTime == 300) {
+  if (config.d_outgoingDoHMaxIdleTime == 300) {
     config.d_outgoingDoHMaxIdleTime = yamlConfig.tuning.doh.outgoing_max_idle_time;
   }
-  if (yamlConfig.tuning.doh.outgoing_cleanup_interval != 60 && config.d_outgoingDoHCleanupInterval == 60) {
+  if (config.d_outgoingDoHCleanupInterval == 60) {
     config.d_outgoingDoHCleanupInterval = yamlConfig.tuning.doh.outgoing_cleanup_interval;
   }
-  if (yamlConfig.tuning.doh.outgoing_max_idle_connection_per_backend != 10 && config.d_outgoingDoHMaxIdlePerBackend == 10) {
+  if (config.d_outgoingDoHMaxIdlePerBackend == 10) {
     config.d_outgoingDoHMaxIdlePerBackend = yamlConfig.tuning.doh.outgoing_max_idle_connection_per_backend;
   }
-  if (yamlConfig.snmp.enabled != false && config.d_snmpEnabled == false) {
+  if (config.d_snmpEnabled == false) {
     config.d_snmpEnabled = yamlConfig.snmp.enabled;
   }
-  if (yamlConfig.snmp.traps_enabled != false && config.d_snmpTrapsEnabled == false) {
+  if (config.d_snmpTrapsEnabled == false) {
     config.d_snmpTrapsEnabled = yamlConfig.snmp.traps_enabled;
   }
-  if (yamlConfig.snmp.daemon_socket != "" && config.d_snmpDaemonSocketPath == "") {
+  if (config.d_snmpDaemonSocketPath == "") {
     config.d_snmpDaemonSocketPath = std::string(yamlConfig.snmp.daemon_socket);
   }
-  if (yamlConfig.load_balancing_policies.weighted_balancing_factor != 0.0 && config.d_weightedBalancingFactor == 0.0) {
+  if (config.d_weightedBalancingFactor == 0.0) {
     config.d_weightedBalancingFactor = yamlConfig.load_balancing_policies.weighted_balancing_factor;
   }
-  if (yamlConfig.load_balancing_policies.consistent_hashing_balancing_factor != 0.0 && config.d_consistentHashBalancingFactor == 0.0) {
+  if (config.d_consistentHashBalancingFactor == 0.0) {
     config.d_consistentHashBalancingFactor = yamlConfig.load_balancing_policies.consistent_hashing_balancing_factor;
   }
-  if (yamlConfig.load_balancing_policies.hash_perturbation != 0 && config.d_hashPerturbation == 0) {
+  if (config.d_hashPerturbation == 0) {
     config.d_hashPerturbation = yamlConfig.load_balancing_policies.hash_perturbation;
   }
 }

diff --git a/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py b/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py
index 92c460afb4ce774fd4a9af2fa84264d579b47b49..755f372f3544d6f1b10251d5e4368c1e68c3ec66 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py
+++ b/pdns/dnsdistdist/dnsdist-rust-lib/dnsdist-settings-generator.py
@@ -336,7 +336,7 @@ void convertRuntimeFlatSettingsFromRust(const dnsdist::rust::settings::GlobalCon
             internal_field_name = parameter['internal-field-name']
             rust_field_name = get_rust_field_name(parameter['name']) if not 'rename' in parameter else parameter['rename']
             default = parameter['default'] if parameter['type'] != 'String' else '"' + parameter['default'] + '"'
-            cxx_flat_settings_fp.write(f'  if (yamlConfig.{category_name}.{rust_field_name} != {default} && config.{internal_field_name} == {default}) {{\n')
+            cxx_flat_settings_fp.write(f'  if (config.{internal_field_name} == {default}) {{\n')
             if parameter['type'] != 'String':
                 cxx_flat_settings_fp.write(f'    config.{internal_field_name} = yamlConfig.{category_name}.{rust_field_name};\n')
             else:
@@ -363,7 +363,7 @@ void convertRuntimeFlatSettingsFromRust(const dnsdist::rust::settings::GlobalCon
             internal_field_name = parameter['internal-field-name']
             rust_field_name = get_rust_field_name(parameter['name']) if not 'rename' in parameter else parameter['rename']
             default = parameter['default'] if parameter['type'] != 'String' else '"' + parameter['default'] + '"'
-            cxx_flat_settings_fp.write(f'  if (yamlConfig.{category_name}.{rust_field_name} != {default} && config.{internal_field_name} == {default}) {{\n')
+            cxx_flat_settings_fp.write(f'  if (config.{internal_field_name} == {default}) {{\n')
             if parameter['type'] != 'String':
                 cxx_flat_settings_fp.write(f'    config.{internal_field_name} = yamlConfig.{category_name}.{rust_field_name};\n')
             else: