dnsdist: Move the Lua bindings for single items to a separate file

diff --git a/pdns/dnsdistdist/Makefile.am b/pdns/dnsdistdist/Makefile.am
index 6c17d416e19b3ee547360352cd8a8b1c50f2d1dd..a704f6a2aa989fc6ef8f0820c04b8e4bcb85f094 100644 (file)
--- a/pdns/dnsdistdist/Makefile.am
+++ b/pdns/dnsdistdist/Makefile.am
@@ -180,6 +180,7 @@ dnsdist_SOURCES = \
        dnsdist-lua-bindings-protobuf.cc \
        dnsdist-lua-bindings-rings.cc \
        dnsdist-lua-bindings.cc \
+       dnsdist-lua-configuration-items.cc \
        dnsdist-lua-ffi-interface.h dnsdist-lua-ffi-interface.inc \
        dnsdist-lua-ffi.cc dnsdist-lua-ffi.hh \
        dnsdist-lua-hooks.cc dnsdist-lua-hooks.hh \

diff --git a/pdns/dnsdistdist/dnsdist-lua-configuration-items.cc b/pdns/dnsdistdist/dnsdist-lua-configuration-items.cc
new file mode 100644 (file)
index 0000000..6c07c07
--- /dev/null
+++ b/pdns/dnsdistdist/dnsdist-lua-configuration-items.cc
@@ -0,0 +1,239 @@
+/*
+ * This file is part of PowerDNS or dnsdist.
+ * Copyright -- PowerDNS.COM B.V. and its contributors
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * In addition, for the avoidance of any doubt, permission is granted to
+ * link this program with OpenSSL and to (re)distribute the binaries
+ * produced as the result of such linking.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <string>
+#include <vector>
+
+#include "config.h"
+#include "dnsdist-configuration.hh"
+#include "dnsdist-lua.hh"
+#include "dolog.hh"
+
+namespace dnsdist::lua
+{
+struct BooleanConfigurationItems
+{
+  const std::function<void(dnsdist::configuration::RuntimeConfiguration& config, bool newValue)> mutator;
+};
+
+struct UnsignedIntegerConfigurationItems
+{
+  const std::function<void(dnsdist::configuration::RuntimeConfiguration& config, uint64_t value)> mutator;
+  const size_t maximumValue{std::numeric_limits<uint64_t>::max()};
+};
+
+struct StringConfigurationItems
+{
+  const std::function<void(dnsdist::configuration::RuntimeConfiguration& config, const std::string& value)> mutator;
+};
+
+struct BooleanImmutableConfigurationItems
+{
+  const std::function<void(dnsdist::configuration::ImmutableConfiguration& config, bool newValue)> mutator;
+};
+struct UnsignedIntegerImmutableConfigurationItems
+{
+  const std::function<void(dnsdist::configuration::ImmutableConfiguration& config, uint64_t value)> mutator;
+  const size_t maximumValue{std::numeric_limits<uint64_t>::max()};
+};
+
+struct DoubleImmutableConfigurationItems
+{
+  const std::function<void(dnsdist::configuration::ImmutableConfiguration& config, double value)> mutator;
+  const double minimumValue{1.0};
+};
+
+// clang-format off
+static const std::map<std::string, BooleanConfigurationItems> s_booleanConfigItems{
+  {"truncateTC", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_truncateTC = newValue; }}},
+  {"fixupCase", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_fixupCase = newValue; }}},
+  {"setECSOverride", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_ecsOverride = newValue; }}},
+  {"setQueryCount", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_queryCountConfig.d_enabled = newValue; }}},
+  {"setVerbose", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_verbose = newValue; }}},
+  {"setVerboseHealthChecks", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_verboseHealthChecks = newValue; }}},
+  {"setServFailWhenNoServer", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_servFailOnNoPolicy = newValue; }}},
+  {"setRoundRobinFailOnNoServer", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_roundrobinFailOnNoServer = newValue; }}},
+  {"setDropEmptyQueries", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_dropEmptyQueries = newValue; }}},
+  {"setAllowEmptyResponse", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_allowEmptyResponse = newValue; }}},
+  {"setConsoleConnectionsLogging", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_logConsoleConnections = newValue; }}},
+  {"setProxyProtocolApplyACLToProxiedClients", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_applyACLToProxiedClients = newValue; }}},
+  {"setAddEDNSToSelfGeneratedResponses", {[](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_addEDNSToSelfGeneratedResponses = newValue; }}},
+};
+
+static const std::map<std::string, UnsignedIntegerConfigurationItems> s_unsignedIntegerConfigItems{
+  {"setCacheCleaningDelay", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_cacheCleaningDelay = newValue; }, std::numeric_limits<uint32_t>::max()}},
+  {"setCacheCleaningPercentage", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_cacheCleaningPercentage = newValue; }, 100U}},
+  {"setOutgoingTLSSessionsCacheMaxTicketsPerBackend", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tlsSessionCacheMaxSessionsPerBackend = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setOutgoingTLSSessionsCacheCleanupDelay", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tlsSessionCacheCleanupDelay = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setOutgoingTLSSessionsCacheMaxTicketValidity", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tlsSessionCacheSessionValidity = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setECSSourcePrefixV4", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_ECSSourcePrefixV4 = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setECSSourcePrefixV6", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_ECSSourcePrefixV6 = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setTCPRecvTimeout", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tcpRecvTimeout = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setTCPSendTimeout", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tcpSendTimeout = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setMaxTCPQueriesPerConnection", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_maxTCPQueriesPerConn = newValue; }, std::numeric_limits<uint64_t>::max()}},
+  {"setMaxTCPConnectionDuration", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_maxTCPConnectionDuration = newValue; }, std::numeric_limits<uint32_t>::max()}},
+  {"setStaleCacheEntriesTTL", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_staleCacheEntriesTTL = newValue; }, std::numeric_limits<uint32_t>::max()}},
+  {"setConsoleOutputMaxMsgSize", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_consoleOutputMsgMaxSize = newValue; }, std::numeric_limits<uint32_t>::max()}},
+#ifndef DISABLE_SECPOLL
+  {"setSecurityPollInterval", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_secPollInterval = newValue; }, std::numeric_limits<uint32_t>::max()}},
+#endif /* DISABLE_SECPOLL */
+  {"setProxyProtocolMaximumPayloadSize", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_proxyProtocolMaximumSize = std::max(static_cast<uint64_t>(16), newValue); }, std::numeric_limits<uint32_t>::max()}},
+  {"setPayloadSizeOnSelfGeneratedAnswers", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) {
+    if (newValue < 512) {
+      warnlog("setPayloadSizeOnSelfGeneratedAnswers() is set too low, using 512 instead!");
+      g_outputBuffer = "setPayloadSizeOnSelfGeneratedAnswers() is set too low, using 512 instead!";
+      newValue = 512;
+    }
+    if (newValue > dnsdist::configuration::s_udpIncomingBufferSize) {
+      warnlog("setPayloadSizeOnSelfGeneratedAnswers() is set too high, capping to %d instead!", dnsdist::configuration::s_udpIncomingBufferSize);
+      g_outputBuffer = "setPayloadSizeOnSelfGeneratedAnswers() is set too high, capping to " + std::to_string(dnsdist::configuration::s_udpIncomingBufferSize) + " instead";
+      newValue = dnsdist::configuration::s_udpIncomingBufferSize;
+    }
+    config.d_payloadSizeSelfGenAnswers = newValue;
+  },
+   std::numeric_limits<uint64_t>::max()}},
+#ifndef DISABLE_DYNBLOCKS
+  {"setDynBlocksPurgeInterval", {[](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_dynBlocksPurgeInterval = newValue; }, std::numeric_limits<uint32_t>::max()}},
+#endif /* DISABLE_DYNBLOCKS */
+};
+
+static const std::map<std::string, StringConfigurationItems> s_stringConfigItems{
+#ifndef DISABLE_SECPOLL
+  {"setSecurityPollSuffix", {[](dnsdist::configuration::RuntimeConfiguration& config, const std::string& newValue) { config.d_secPollSuffix = newValue; }}},
+#endif /* DISABLE_SECPOLL */
+};
+
+static const std::map<std::string, BooleanImmutableConfigurationItems> s_booleanImmutableConfigItems{
+  {"setRandomizedOutgoingSockets", {[](dnsdist::configuration::ImmutableConfiguration& config, bool newValue) { config.d_randomizeUDPSocketsToBackend = newValue; }}},
+  {"setRandomizedIdsOverUDP", {[](dnsdist::configuration::ImmutableConfiguration& config, bool newValue) { config.d_randomizeIDsToBackend = newValue; }}},
+};
+
+static const std::map<std::string, UnsignedIntegerImmutableConfigurationItems> s_unsignedIntegerImmutableConfigItems{
+  {"setMaxTCPQueuedConnections", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxTCPQueuedConnections = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setMaxTCPClientThreads", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxTCPClientThreads = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setMaxTCPConnectionsPerClient", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxTCPConnectionsPerClient = newValue; }, std::numeric_limits<uint64_t>::max()}},
+  {"setTCPInternalPipeBufferSize", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_tcpInternalPipeBufferSize = newValue; }, std::numeric_limits<uint64_t>::max()}},
+  {"setMaxCachedTCPConnectionsPerDownstream", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdlePerBackend = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setTCPDownstreamCleanupInterval", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingTCPCleanupInterval = newValue; }, std::numeric_limits<uint32_t>::max()}},
+  {"setTCPDownstreamMaxIdleTime", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdleTime = newValue; }, std::numeric_limits<uint16_t>::max()}},
+#if defined(HAVE_DNS_OVER_HTTPS) && defined(HAVE_NGHTTP2)
+  {"setOutgoingDoHWorkerThreads", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHWorkers = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setMaxIdleDoHConnectionsPerDownstream", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdlePerBackend = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setDoHDownstreamCleanupInterval", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHCleanupInterval = newValue; }, std::numeric_limits<uint32_t>::max()}},
+  {"setDoHDownstreamMaxIdleTime", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdleTime = newValue; }, std::numeric_limits<uint16_t>::max()}},
+#endif /* HAVE_DNS_OVER_HTTPS && HAVE_NGHTTP2 */
+  {"setMaxUDPOutstanding", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxUDPOutstanding = newValue; }, std::numeric_limits<uint16_t>::max()}},
+  {"setWHashedPertubation", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_hashPerturbation = newValue; }, std::numeric_limits<uint32_t>::max()}},
+#ifndef DISABLE_RECVMMSG
+  {"setUDPMultipleMessagesVectorSize", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_udpVectorSize = newValue; }, std::numeric_limits<uint32_t>::max()}},
+#endif /* DISABLE_RECVMMSG */
+  {"setUDPTimeout", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_udpTimeout = newValue; }, std::numeric_limits<uint8_t>::max()}},
+  {"setConsoleMaximumConcurrentConnections", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_consoleMaxConcurrentConnections = newValue; }, std::numeric_limits<uint32_t>::max()}},
+  {"setRingBuffersLockRetries", {[](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_ringsNbLockTries = newValue; }, std::numeric_limits<uint64_t>::max()}},
+};
+
+static const std::map<std::string, DoubleImmutableConfigurationItems> s_doubleImmutableConfigItems{
+  {"setConsistentHashingBalancingFactor", {[](dnsdist::configuration::ImmutableConfiguration& config, double newValue) { config.d_consistentHashBalancingFactor = newValue; }, 1.0}},
+  {"setWeightedBalancingFactor", {[](dnsdist::configuration::ImmutableConfiguration& config, double newValue) { config.d_weightedBalancingFactor = newValue; }, 1.0}},
+};
+// clang-format on
+
+void setupConfigurationItems(LuaContext& luaCtx)
+{
+  for (const auto& item : s_booleanConfigItems) {
+    luaCtx.writeFunction(item.first, [&item = item.second](bool value) {
+      setLuaSideEffect();
+      dnsdist::configuration::updateRuntimeConfiguration([value, &item](dnsdist::configuration::RuntimeConfiguration& config) {
+        item.mutator(config, value);
+      });
+    });
+  }
+
+  for (const auto& item : s_unsignedIntegerConfigItems) {
+    luaCtx.writeFunction(item.first, [&name = item.first, &item = item.second](uint64_t value) {
+      setLuaSideEffect();
+      checkParameterBound(name, value, item.maximumValue);
+      dnsdist::configuration::updateRuntimeConfiguration([value, &item](dnsdist::configuration::RuntimeConfiguration& config) {
+        item.mutator(config, value);
+      });
+    });
+  }
+
+  for (const auto& item : s_stringConfigItems) {
+    luaCtx.writeFunction(item.first, [&item = item.second](const std::string& value) {
+      setLuaSideEffect();
+      dnsdist::configuration::updateRuntimeConfiguration([value, &item](dnsdist::configuration::RuntimeConfiguration& config) {
+        item.mutator(config, value);
+      });
+    });
+  }
+
+  for (const auto& item : s_booleanImmutableConfigItems) {
+    luaCtx.writeFunction(item.first, [&name = item.first, &item = item.second](bool value) {
+      try {
+        dnsdist::configuration::updateImmutableConfiguration([value, &item](dnsdist::configuration::ImmutableConfiguration& config) {
+          item.mutator(config, value);
+        });
+      }
+      catch (const std::exception& exp) {
+        g_outputBuffer = name + " cannot be used at runtime!\n";
+        errlog("%s cannot be used at runtime!", name);
+      }
+    });
+  }
+
+  for (const auto& item : s_unsignedIntegerImmutableConfigItems) {
+    luaCtx.writeFunction(item.first, [&name = item.first, &item = item.second](uint64_t value) {
+      checkParameterBound(name, value, item.maximumValue);
+      try {
+        dnsdist::configuration::updateImmutableConfiguration([value, &item](dnsdist::configuration::ImmutableConfiguration& config) {
+          item.mutator(config, value);
+        });
+      }
+      catch (const std::exception& exp) {
+        g_outputBuffer = name + " cannot be used at runtime!\n";
+        errlog("%s cannot be used at runtime!", name);
+      }
+    });
+  }
+  for (const auto& item : s_doubleImmutableConfigItems) {
+    luaCtx.writeFunction(item.first, [&name = item.first, &item = item.second](double value) {
+      if (value != 0 && value < item.minimumValue) {
+        g_outputBuffer = "Invalid value passed to " + name + "()!\n";
+        errlog("Invalid value passed to %s()!", name);
+        return;
+      }
+
+      try {
+        dnsdist::configuration::updateImmutableConfiguration([value, &item](dnsdist::configuration::ImmutableConfiguration& config) {
+          item.mutator(config, value);
+        });
+      }
+      catch (const std::exception& exp) {
+        g_outputBuffer = name + " cannot be used at runtime!\n";
+        errlog("%s cannot be used at runtime!", name);
+      }
+      setLuaSideEffect();
+    });
+  }
+}
+}

diff --git a/pdns/dnsdistdist/dnsdist-lua.cc b/pdns/dnsdistdist/dnsdist-lua.cc
index 61f19e61935565e62cbca7e3902513a3d908e358..d9cd687393c34b37ea58d2f59ebfd67cc520378e 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-lua.cc
+++ b/pdns/dnsdistdist/dnsdist-lua.cc
@@ -409,6 +409,8 @@ static void handleNewServerSourceParameter(boost::optional<newserver_t>& vars, D
 // NOLINTNEXTLINE(readability-function-cognitive-complexity,readability-function-size): this function declares Lua bindings, even with a good refactoring it will likely blow up the threshold
 static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
 {
+  dnsdist::lua::setupConfigurationItems(luaCtx);
+
   luaCtx.writeFunction("inClientStartup", [client]() {
     return client && !dnsdist::configuration::isImmutableConfigurationDone();
   });
@@ -716,208 +718,6 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
                          server->stop();
                        });
 
-  struct BooleanConfigurationItems
-  {
-    const std::string name;
-    const std::function<void(dnsdist::configuration::RuntimeConfiguration& config, bool newValue)> mutator;
-  };
-  static const std::vector<BooleanConfigurationItems> booleanConfigItems{
-    {"truncateTC", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_truncateTC = newValue; }},
-    {"fixupCase", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_fixupCase = newValue; }},
-    {"setECSOverride", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_ecsOverride = newValue; }},
-    {"setQueryCount", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_queryCountConfig.d_enabled = newValue; }},
-    {"setVerbose", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_verbose = newValue; }},
-    {"setVerboseHealthChecks", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_verboseHealthChecks = newValue; }},
-    {"setServFailWhenNoServer", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_servFailOnNoPolicy = newValue; }},
-    {"setRoundRobinFailOnNoServer", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_roundrobinFailOnNoServer = newValue; }},
-    {"setDropEmptyQueries", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_dropEmptyQueries = newValue; }},
-    {"setAllowEmptyResponse", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_allowEmptyResponse = newValue; }},
-    {"setConsoleConnectionsLogging", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_logConsoleConnections = newValue; }},
-    {"setProxyProtocolApplyACLToProxiedClients", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_applyACLToProxiedClients = newValue; }},
-    {"setAddEDNSToSelfGeneratedResponses", [](dnsdist::configuration::RuntimeConfiguration& config, bool newValue) { config.d_addEDNSToSelfGeneratedResponses = newValue; }},
-  };
-  struct UnsignedIntegerConfigurationItems
-  {
-    const std::string name;
-    const std::function<void(dnsdist::configuration::RuntimeConfiguration& config, uint64_t value)> mutator;
-    const size_t maximumValue{std::numeric_limits<uint64_t>::max()};
-  };
-  static const std::vector<UnsignedIntegerConfigurationItems> unsignedIntegerConfigItems{
-    {"setCacheCleaningDelay", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_cacheCleaningDelay = newValue; }, std::numeric_limits<uint32_t>::max()},
-    {"setCacheCleaningPercentage", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_cacheCleaningPercentage = newValue; }, 100U},
-    {"setOutgoingTLSSessionsCacheMaxTicketsPerBackend", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tlsSessionCacheMaxSessionsPerBackend = newValue; }, std::numeric_limits<uint16_t>::max()},
-    {"setOutgoingTLSSessionsCacheCleanupDelay", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tlsSessionCacheCleanupDelay = newValue; }, std::numeric_limits<uint16_t>::max()},
-    {"setOutgoingTLSSessionsCacheMaxTicketValidity", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tlsSessionCacheSessionValidity = newValue; }, std::numeric_limits<uint16_t>::max()},
-    {"setECSSourcePrefixV4", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_ECSSourcePrefixV4 = newValue; }, std::numeric_limits<uint16_t>::max()},
-    {"setECSSourcePrefixV6", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_ECSSourcePrefixV6 = newValue; }, std::numeric_limits<uint16_t>::max()},
-    {"setTCPRecvTimeout", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tcpRecvTimeout = newValue; }, std::numeric_limits<uint16_t>::max()},
-    {"setTCPSendTimeout", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_tcpSendTimeout = newValue; }, std::numeric_limits<uint16_t>::max()},
-    {"setMaxTCPQueriesPerConnection", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_maxTCPQueriesPerConn = newValue; }, std::numeric_limits<uint64_t>::max()},
-    {"setMaxTCPConnectionDuration", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_maxTCPConnectionDuration = newValue; }, std::numeric_limits<uint32_t>::max()},
-    {"setStaleCacheEntriesTTL", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_staleCacheEntriesTTL = newValue; }, std::numeric_limits<uint32_t>::max()},
-    {"setConsoleOutputMaxMsgSize", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_consoleOutputMsgMaxSize = newValue; }, std::numeric_limits<uint32_t>::max()},
-#ifndef DISABLE_SECPOLL
-    {"setSecurityPollInterval", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_secPollInterval = newValue; }, std::numeric_limits<uint32_t>::max()},
-#endif /* DISABLE_SECPOLL */
-    {"setProxyProtocolMaximumPayloadSize", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_proxyProtocolMaximumSize = std::max(static_cast<uint64_t>(16), newValue); }, std::numeric_limits<uint32_t>::max()},
-    {"setPayloadSizeOnSelfGeneratedAnswers", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) {
-       if (newValue < 512) {
-         warnlog("setPayloadSizeOnSelfGeneratedAnswers() is set too low, using 512 instead!");
-         g_outputBuffer = "setPayloadSizeOnSelfGeneratedAnswers() is set too low, using 512 instead!";
-         newValue = 512;
-       }
-       if (newValue > dnsdist::configuration::s_udpIncomingBufferSize) {
-         warnlog("setPayloadSizeOnSelfGeneratedAnswers() is set too high, capping to %d instead!", dnsdist::configuration::s_udpIncomingBufferSize);
-         g_outputBuffer = "setPayloadSizeOnSelfGeneratedAnswers() is set too high, capping to " + std::to_string(dnsdist::configuration::s_udpIncomingBufferSize) + " instead";
-         newValue = dnsdist::configuration::s_udpIncomingBufferSize;
-       }
-       config.d_payloadSizeSelfGenAnswers = newValue;
-     },
-     std::numeric_limits<uint64_t>::max()},
-#ifndef DISABLE_DYNBLOCKS
-    {"setDynBlocksPurgeInterval", [](dnsdist::configuration::RuntimeConfiguration& config, uint64_t newValue) { config.d_dynBlocksPurgeInterval = newValue; }, std::numeric_limits<uint32_t>::max()},
-#endif /* DISABLE_DYNBLOCKS */
-  };
-
-  struct StringConfigurationItems
-  {
-    const std::string name;
-    const std::function<void(dnsdist::configuration::RuntimeConfiguration& config, const std::string& value)> mutator;
-  };
-  static const std::vector<StringConfigurationItems> stringConfigItems{
-#ifndef DISABLE_SECPOLL
-    {"setSecurityPollSuffix", [](dnsdist::configuration::RuntimeConfiguration& config, const std::string& newValue) { config.d_secPollSuffix = newValue; }},
-#endif /* DISABLE_SECPOLL */
-  };
-
-  for (const auto& item : booleanConfigItems) {
-    luaCtx.writeFunction(item.name, [&item](bool value) {
-      setLuaSideEffect();
-      dnsdist::configuration::updateRuntimeConfiguration([value, &item](dnsdist::configuration::RuntimeConfiguration& config) {
-        item.mutator(config, value);
-      });
-    });
-  }
-
-  for (const auto& item : unsignedIntegerConfigItems) {
-    luaCtx.writeFunction(item.name, [&item](uint64_t value) {
-      setLuaSideEffect();
-      checkParameterBound(item.name, value, item.maximumValue);
-      dnsdist::configuration::updateRuntimeConfiguration([value, &item](dnsdist::configuration::RuntimeConfiguration& config) {
-        item.mutator(config, value);
-      });
-    });
-  }
-
-  for (const auto& item : stringConfigItems) {
-    luaCtx.writeFunction(item.name, [&item](const std::string& value) {
-      setLuaSideEffect();
-      dnsdist::configuration::updateRuntimeConfiguration([value, &item](dnsdist::configuration::RuntimeConfiguration& config) {
-        item.mutator(config, value);
-      });
-    });
-  }
-
-  struct BooleanImmutableConfigurationItems
-  {
-    const std::string name;
-    const std::function<void(dnsdist::configuration::ImmutableConfiguration& config, bool newValue)> mutator;
-  };
-  static const std::vector<BooleanImmutableConfigurationItems> booleanImmutableConfigItems{
-    {"setRandomizedOutgoingSockets", [](dnsdist::configuration::ImmutableConfiguration& config, bool newValue) { config.d_randomizeUDPSocketsToBackend = newValue; }},
-    {"setRandomizedIdsOverUDP", [](dnsdist::configuration::ImmutableConfiguration& config, bool newValue) { config.d_randomizeIDsToBackend = newValue; }},
-  };
-  struct UnsignedIntegerImmutableConfigurationItems
-  {
-    const std::string name;
-    const std::function<void(dnsdist::configuration::ImmutableConfiguration& config, uint64_t value)> mutator;
-    const size_t maximumValue{std::numeric_limits<uint64_t>::max()};
-  };
-  static const std::vector<UnsignedIntegerImmutableConfigurationItems> unsignedIntegerImmutableConfigItems
-  {
-    {"setMaxTCPQueuedConnections", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxTCPQueuedConnections = newValue; }, std::numeric_limits<uint16_t>::max()},
-      {"setMaxTCPClientThreads", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxTCPClientThreads = newValue; }, std::numeric_limits<uint16_t>::max()},
-      {"setMaxTCPConnectionsPerClient", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxTCPConnectionsPerClient = newValue; }, std::numeric_limits<uint64_t>::max()},
-      {"setTCPInternalPipeBufferSize", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_tcpInternalPipeBufferSize = newValue; }, std::numeric_limits<uint64_t>::max()},
-      {"setMaxCachedTCPConnectionsPerDownstream", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdlePerBackend = newValue; }, std::numeric_limits<uint16_t>::max()},
-      {"setTCPDownstreamCleanupInterval", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingTCPCleanupInterval = newValue; }, std::numeric_limits<uint32_t>::max()},
-      {"setTCPDownstreamMaxIdleTime", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdleTime = newValue; }, std::numeric_limits<uint16_t>::max()},
-#if defined(HAVE_DNS_OVER_HTTPS) && defined(HAVE_NGHTTP2)
-      {"setOutgoingDoHWorkerThreads", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHWorkers = newValue; }, std::numeric_limits<uint16_t>::max()},
-      {"setMaxIdleDoHConnectionsPerDownstream", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdlePerBackend = newValue; }, std::numeric_limits<uint16_t>::max()},
-      {"setDoHDownstreamCleanupInterval", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHCleanupInterval = newValue; }, std::numeric_limits<uint32_t>::max()},
-      {"setDoHDownstreamMaxIdleTime", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdleTime = newValue; }, std::numeric_limits<uint16_t>::max()},
-#endif /* HAVE_DNS_OVER_HTTPS && HAVE_NGHTTP2 */
-      {"setMaxUDPOutstanding", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_maxUDPOutstanding = newValue; }, std::numeric_limits<uint16_t>::max()},
-      {"setWHashedPertubation", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_hashPerturbation = newValue; }, std::numeric_limits<uint32_t>::max()},
-#ifndef DISABLE_RECVMMSG
-      {"setUDPMultipleMessagesVectorSize", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_udpVectorSize = newValue; }, std::numeric_limits<uint32_t>::max()},
-#endif /* DISABLE_RECVMMSG */
-      {"setUDPTimeout", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_udpTimeout = newValue; }, std::numeric_limits<uint8_t>::max()},
-      {"setConsoleMaximumConcurrentConnections", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_consoleMaxConcurrentConnections = newValue; }, std::numeric_limits<uint32_t>::max()},
-      {"setRingBuffersLockRetries", [](dnsdist::configuration::ImmutableConfiguration& config, uint64_t newValue) { config.d_ringsNbLockTries = newValue; }, std::numeric_limits<uint64_t>::max()},
-  };
-
-  struct DoubleImmutableConfigurationItems
-  {
-    const std::string name;
-    const std::function<void(dnsdist::configuration::ImmutableConfiguration& config, double value)> mutator;
-    const double minimumValue{1.0};
-  };
-  static const std::vector<DoubleImmutableConfigurationItems> doubleImmutableConfigItems{
-    {"setConsistentHashingBalancingFactor", [](dnsdist::configuration::ImmutableConfiguration& config, double newValue) { config.d_consistentHashBalancingFactor = newValue; }, 1.0},
-    {"setWeightedBalancingFactor", [](dnsdist::configuration::ImmutableConfiguration& config, double newValue) { config.d_weightedBalancingFactor = newValue; }, 1.0},
-  };
-
-  for (const auto& item : booleanImmutableConfigItems) {
-    luaCtx.writeFunction(item.name, [&item](bool value) {
-      try {
-        dnsdist::configuration::updateImmutableConfiguration([value, &item](dnsdist::configuration::ImmutableConfiguration& config) {
-          item.mutator(config, value);
-        });
-      }
-      catch (const std::exception& exp) {
-        g_outputBuffer = item.name + " cannot be used at runtime!\n";
-        errlog("%s cannot be used at runtime!", item.name);
-      }
-    });
-  }
-
-  for (const auto& item : unsignedIntegerImmutableConfigItems) {
-    luaCtx.writeFunction(item.name, [&item](uint64_t value) {
-      checkParameterBound(item.name, value, item.maximumValue);
-      try {
-        dnsdist::configuration::updateImmutableConfiguration([value, &item](dnsdist::configuration::ImmutableConfiguration& config) {
-          item.mutator(config, value);
-        });
-      }
-      catch (const std::exception& exp) {
-        g_outputBuffer = item.name + " cannot be used at runtime!\n";
-        errlog("%s cannot be used at runtime!", item.name);
-      }
-    });
-  }
-  for (const auto& item : doubleImmutableConfigItems) {
-    luaCtx.writeFunction(item.name, [&item](double value) {
-      if (value != 0 && value < item.minimumValue) {
-        g_outputBuffer = "Invalid value passed to " + item.name + "()!\n";
-        errlog("Invalid value passed to %s()!", item.name);
-        return;
-      }
-
-      try {
-        dnsdist::configuration::updateImmutableConfiguration([value, &item](dnsdist::configuration::ImmutableConfiguration& config) {
-          item.mutator(config, value);
-        });
-      }
-      catch (const std::exception& exp) {
-        g_outputBuffer = item.name + " cannot be used at runtime!\n";
-        errlog("%s cannot be used at runtime!", item.name);
-      }
-      setLuaSideEffect();
-    });
-  }
-
   luaCtx.writeFunction("getVerbose", []() { return dnsdist::configuration::getCurrentRuntimeConfiguration().d_verbose; });
 
   luaCtx.writeFunction("addACL", [](const std::string& mask) {

diff --git a/pdns/dnsdistdist/dnsdist-lua.hh b/pdns/dnsdistdist/dnsdist-lua.hh
index 34d821f81dfd7382bce5388e20df009dacbd3c06..e20485b0eb546fe2fc7a69f79573c6c6bd6a6fcb 100644 (file)
--- a/pdns/dnsdistdist/dnsdist-lua.hh
+++ b/pdns/dnsdistdist/dnsdist-lua.hh
@@ -62,6 +62,11 @@ void setupLuaVars(LuaContext& luaCtx);
 void setupLuaWeb(LuaContext& luaCtx);
 void setupLuaLoadBalancingContext(LuaContext& luaCtx);
 
+namespace dnsdist::lua
+{
+void setupConfigurationItems(LuaContext& luaCtx);
+}
+
 /**
  * getOptionalValue(vars, key, value)
  *