dnsdist: Move rules to the new configuration

pdns/dnsdistdist/dnsdist-async.cc

@@ -222,8 +222,7 @@ static bool resumeResponse(std::unique_ptr<CrossProtocolQuery>&& response)
     auto& ids = response->query.d_idstate;
     DNSResponse dnsResponse = response->getDR();
 
-    LocalHolders holders;
-    auto result = processResponseAfterRules(response->query.d_buffer, *holders.cacheInsertedRespRuleActions, dnsResponse, ids.cs->muted);
+    auto result = processResponseAfterRules(response->query.d_buffer, dnsResponse, ids.cs->muted);
     if (!result) {
       /* easy */
       return true;

pdns/dnsdistdist/dnsdist-configuration.hh

@@ -26,6 +26,7 @@
 #include <string>
 
 #include "dnsdist-query-count.hh"
+#include "dnsdist-rule-chains.hh"
 #include "iputils.hh"
 
 /* so what could you do:
@@ -184,6 +185,16 @@ struct Configuration
    a RCU-like mechanism */
 struct RuntimeConfiguration
 {
+  // ca tient pas la route: meilleure option: stocker un type plus opaque dans la configuration (dnsdist::rules::RuleChains) et
+  // laisser le soin a dnsdist::rules de le gerer
+  /*  std::vector<rules::RuleAction> d_cacheMissRuleActions;
+  std::vector<rules::ResponseRuleAction> d_respruleactions;
+  std::vector<rules::ResponseRuleAction> d_cachehitrespruleactions;
+  std::vector<rules::ResponseRuleAction> d_selfansweredrespruleactions;
+  std::vector<rules::ResponseRuleAction> d_cacheInsertedRespRuleActions;
+  std::vector<rules::ResponseRuleAction> d_XFRRespRuleActions;
+  */
+  rules::RuleChains d_ruleChains;
   servers_t d_backends;
   std::map<std::string, std::shared_ptr<ServerPool>> d_pools;
   std::shared_ptr<ServerPolicy> d_lbPolicy;

pdns/dnsdistdist/dnsdist-lua-actions.cc

@@ -2376,8 +2376,8 @@ class SetExtendedDNSErrorResponseAction : public DNSResponseAction
   EDNSExtendedError d_ede;
 };
 
-template <typename T, typename ActionT>
-static void addAction(GlobalStateHolder<vector<T>>* someRuleActions, const luadnsrule_t& var, const std::shared_ptr<ActionT>& action, boost::optional<luaruleparams_t>& params)
+template <typename ActionT, typename IdentifierT>
+static void addAction(IdentifierT identifier, const luadnsrule_t& var, const std::shared_ptr<ActionT>& action, boost::optional<luaruleparams_t>& params)
 {
   setLuaSideEffect();
 
@@ -2388,8 +2388,8 @@ static void addAction(GlobalStateHolder<vector<T>>* someRuleActions, const luadn
   checkAllParametersConsumed("addAction", params);
 
   auto rule = makeRule(var, "addAction");
-  someRuleActions->modify([&rule, &action, &uuid, creationOrder, &name](vector<T>& ruleactions) {
-    ruleactions.push_back({std::move(rule), std::move(action), std::move(name), uuid, creationOrder});
+  dnsdist::configuration::updateRuntimeConfiguration([identifier, &rule, &action, &name, &uuid, creationOrder](dnsdist::configuration::RuntimeConfiguration& config) {
+    dnsdist::rules::add(config.d_ruleChains, identifier, std::move(rule), action, std::move(name), uuid, creationOrder);
   });
 }
 
@@ -2418,35 +2418,36 @@ void setupLuaActions(LuaContext& luaCtx)
     return std::make_shared<dnsdist::rules::RuleAction>(ruleaction);
   });
 
-  for (const auto& chain : dnsdist::rules::getRuleChains()) {
+  for (const auto& chain : dnsdist::rules::getRuleChainDescriptions()) {
     auto fullName = std::string("add") + chain.prefix + std::string("Action");
     luaCtx.writeFunction(fullName, [&fullName, &chain](const luadnsrule_t& var, boost::variant<std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>> era, boost::optional<luaruleparams_t> params) {
       if (era.type() != typeid(std::shared_ptr<DNSAction>)) {
         throw std::runtime_error(fullName + "() can only be called with query-related actions, not response-related ones. Are you looking for addResponseAction()?");
       }
 
-      addAction(&chain.holder, var, boost::get<std::shared_ptr<DNSAction>>(era), params);
+      addAction(chain.identifier, var, boost::get<std::shared_ptr<DNSAction>>(era), params);
     });
     fullName = std::string("get") + chain.prefix + std::string("Action");
     luaCtx.writeFunction(fullName, [&chain](unsigned int num) {
       setLuaNoSideEffect();
       boost::optional<std::shared_ptr<DNSAction>> ret;
-      auto ruleactions = chain.holder.getCopy();
+      const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
+      const auto& ruleactions = dnsdist::rules::getRuleChain(chains, chain.identifier);
       if (num < ruleactions.size()) {
         ret = ruleactions[num].d_action;
       }
       return ret;
     });
   }
 
-  for (const auto& chain : dnsdist::rules::getResponseRuleChains()) {
+  for (const auto& chain : dnsdist::rules::getResponseRuleChainDescriptions()) {
     const auto fullName = std::string("add") + chain.prefix + std::string("ResponseAction");
     luaCtx.writeFunction(fullName, [&fullName, &chain](const luadnsrule_t& var, boost::variant<std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>> era, boost::optional<luaruleparams_t> params) {
       if (era.type() != typeid(std::shared_ptr<DNSResponseAction>)) {
         throw std::runtime_error(fullName + "() can only be called with response-related actions, not query-related ones. Are you looking for addAction()?");
       }
 
-      addAction(&chain.holder, var, boost::get<std::shared_ptr<DNSResponseAction>>(era), params);
+      addAction(chain.identifier, var, boost::get<std::shared_ptr<DNSResponseAction>>(era), params);
     });
   }
 

pdns/dnsdistdist/dnsdist-lua-bindings.cc

@@ -113,7 +113,7 @@ void setupLuaBindings(LuaContext& luaCtx, bool client, bool configCheck)
   /* DownstreamState */
   luaCtx.registerFunction<void (DownstreamState::*)(int)>("setQPS", [](DownstreamState& state, int lim) { state.qps = lim > 0 ? QPSLimiter(lim, lim) : QPSLimiter(); });
   luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(string)>("addPool", [](const std::shared_ptr<DownstreamState>& state, const string& pool) {
-    addServerToPool( pool, state);
+    addServerToPool(pool, state);
     state->d_config.pools.insert(pool);
   });
   luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(string)>("rmPool", [](const std::shared_ptr<DownstreamState>& state, const string& pool) {