From: Remi Gacogne <remi.gacogne@powerdns.com>
Date: Fri, 31 May 2024 12:47:43 +0000 (+0200)
Subject: dnsdist: Move LB policy and pools to the new configuration
X-Git-Tag: rec-5.2.0-alpha1~172^2~21
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=6bd8ef9636f7ddc63a559d609494424910e7e69f;p=thirdparty%2Fpdns.git

dnsdist: Move LB policy and pools to the new configuration
---

diff --git a/pdns/dnsdistdist/dnsdist-carbon.cc b/pdns/dnsdistdist/dnsdist-carbon.cc
index 5ffe257e0b..fe8a83eba3 100644
--- a/pdns/dnsdistdist/dnsdist-carbon.cc
+++ b/pdns/dnsdistdist/dnsdist-carbon.cc
@@ -177,8 +177,7 @@ static bool doOneCarbonExport(const Carbon::Endpoint& endpoint)
       }
     }
 
-    auto localPools = g_pools.getLocal();
-    for (const auto& entry : *localPools) {
+    for (const auto& entry : dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools) {
       string poolName = entry.first;
       boost::replace_all(poolName, ".", "_");
       if (poolName.empty()) {
diff --git a/pdns/dnsdistdist/dnsdist-configuration.hh b/pdns/dnsdistdist/dnsdist-configuration.hh
index bbc6848e4b..8006c6599f 100644
--- a/pdns/dnsdistdist/dnsdist-configuration.hh
+++ b/pdns/dnsdistdist/dnsdist-configuration.hh
@@ -134,6 +134,9 @@ public:
   }
 };
 
+class ServerPolicy;
+struct ServerPool;
+
 namespace dnsdist::configuration
 {
 /* when we add EDNS to a query, we don't want to advertise
@@ -178,6 +181,8 @@ struct Configuration
    a RCU-like mechanism */
 struct RuntimeConfiguration
 {
+  std::map<std::string, std::shared_ptr<ServerPool>> d_pools;
+  std::shared_ptr<ServerPolicy> d_lbPolicy;
   NetmaskGroup d_ACL;
   NetmaskGroup d_proxyProtocolACL;
   NetmaskGroup d_consoleACL;
diff --git a/pdns/dnsdistdist/dnsdist-discovery.cc b/pdns/dnsdistdist/dnsdist-discovery.cc
index ed2a766538..06d9cce3e5 100644
--- a/pdns/dnsdistdist/dnsdist-discovery.cc
+++ b/pdns/dnsdistdist/dnsdist-discovery.cc
@@ -448,14 +448,13 @@ bool ServiceDiscovery::tryToUpgradeBackend(const UpgradeableBackend& backend)
 
     infolog("Added automatically upgraded server %s", newServer->getNameWithAddr());
 
-    auto localPools = g_pools.getCopy();
     if (!newServer->d_config.pools.empty()) {
       for (const auto& poolName : newServer->d_config.pools) {
-        addServerToPool(localPools, poolName, newServer);
+        addServerToPool(poolName, newServer);
       }
     }
     else {
-      addServerToPool(localPools, "", newServer);
+      addServerToPool("", newServer);
     }
 
     newServer->start();
@@ -472,17 +471,16 @@ bool ServiceDiscovery::tryToUpgradeBackend(const UpgradeableBackend& backend)
       }
 
       for (const string& poolName : backend.d_ds->d_config.pools) {
-        removeServerFromPool(localPools, poolName, backend.d_ds);
+        removeServerFromPool(poolName, backend.d_ds);
       }
       /* the server might also be in the default pool */
-      removeServerFromPool(localPools, "", backend.d_ds);
+      removeServerFromPool("", backend.d_ds);
     }
 
     std::stable_sort(states.begin(), states.end(), [](const decltype(newServer)& a, const decltype(newServer)& b) {
       return a->d_config.order < b->d_config.order;
     });
 
-    g_pools.setState(localPools);
     g_dstates.setState(states);
     if (!backend.keepAfterUpgrade) {
       backend.d_ds->stop();
diff --git a/pdns/dnsdistdist/dnsdist-lbpolicies.cc b/pdns/dnsdistdist/dnsdist-lbpolicies.cc
index 99d1f9036b..31d772ddb2 100644
--- a/pdns/dnsdistdist/dnsdist-lbpolicies.cc
+++ b/pdns/dnsdistdist/dnsdist-lbpolicies.cc
@@ -27,8 +27,6 @@
 #include "dolog.hh"
 #include "dns_random.hh"
 
-GlobalStateHolder<ServerPolicy> g_policy;
-
 static constexpr size_t s_staticArrayCutOff = 16;
 template <typename T> using DynamicIndexArray = std::vector<std::pair<T, size_t>>;
 template <typename T> using StaticIndexArray = std::array<std::pair<T, size_t>, s_staticArrayCutOff>;
@@ -258,31 +256,37 @@ shared_ptr<DownstreamState> roundrobin(const ServerPolicy::NumberedServerVector&
   return servers.at(candidates.at((counter++) % candidates.size()) - 1).second;
 }
 
-const std::shared_ptr<const ServerPolicy::NumberedServerVector> getDownstreamCandidates(const pools_t& pools, const std::string& poolName)
+const std::shared_ptr<const ServerPolicy::NumberedServerVector> getDownstreamCandidates(const std::string& poolName)
 {
-  std::shared_ptr<ServerPool> pool = getPool(pools, poolName);
+  std::shared_ptr<ServerPool> pool = getPool(poolName);
   return pool->getServers();
 }
 
-std::shared_ptr<ServerPool> createPoolIfNotExists(pools_t& pools, const string& poolName)
+std::shared_ptr<ServerPool> createPoolIfNotExists(const string& poolName)
 {
-  std::shared_ptr<ServerPool> pool;
-  pools_t::iterator it = pools.find(poolName);
-  if (it != pools.end()) {
-    pool = it->second;
+  {
+    const auto& pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+    const auto it = pools.find(poolName);
+    if (it != pools.end()) {
+      return it->second;
+    }
   }
-  else {
-    if (!poolName.empty())
-      vinfolog("Creating pool %s", poolName);
-    pool = std::make_shared<ServerPool>();
-    pools.insert(std::pair<std::string, std::shared_ptr<ServerPool> >(poolName, pool));
+
+  if (!poolName.empty()) {
+    vinfolog("Creating pool %s", poolName);
   }
+
+  auto pool = std::make_shared<ServerPool>();
+  dnsdist::configuration::updateRuntimeConfiguration([&poolName,&pool](dnsdist::configuration::RuntimeConfiguration& config) {
+    config.d_pools.emplace(poolName, pool);
+  });
+
   return pool;
 }
 
-void setPoolPolicy(pools_t& pools, const string& poolName, std::shared_ptr<ServerPolicy> policy)
+void setPoolPolicy(const string& poolName, std::shared_ptr<ServerPolicy> policy)
 {
-  std::shared_ptr<ServerPool> pool = createPoolIfNotExists(pools, poolName);
+  std::shared_ptr<ServerPool> pool = createPoolIfNotExists(poolName);
   if (!poolName.empty()) {
     vinfolog("Setting pool %s server selection policy to %s", poolName, policy->getName());
   } else {
@@ -291,9 +295,9 @@ void setPoolPolicy(pools_t& pools, const string& poolName, std::shared_ptr<Serve
   pool->policy = std::move(policy);
 }
 
-void addServerToPool(pools_t& pools, const string& poolName, std::shared_ptr<DownstreamState> server)
+void addServerToPool(const string& poolName, std::shared_ptr<DownstreamState> server)
 {
-  std::shared_ptr<ServerPool> pool = createPoolIfNotExists(pools, poolName);
+  std::shared_ptr<ServerPool> pool = createPoolIfNotExists(poolName);
   if (!poolName.empty()) {
     vinfolog("Adding server to pool %s", poolName);
   } else {
@@ -302,9 +306,9 @@ void addServerToPool(pools_t& pools, const string& poolName, std::shared_ptr<Dow
   pool->addServer(server);
 }
 
-void removeServerFromPool(pools_t& pools, const string& poolName, std::shared_ptr<DownstreamState> server)
+void removeServerFromPool(const string& poolName, std::shared_ptr<DownstreamState> server)
 {
-  std::shared_ptr<ServerPool> pool = getPool(pools, poolName);
+  std::shared_ptr<ServerPool> pool = getPool(poolName);
 
   if (!poolName.empty()) {
     vinfolog("Removing server from pool %s", poolName);
@@ -316,10 +320,10 @@ void removeServerFromPool(pools_t& pools, const string& poolName, std::shared_pt
   pool->removeServer(server);
 }
 
-std::shared_ptr<ServerPool> getPool(const pools_t& pools, const std::string& poolName)
+std::shared_ptr<ServerPool> getPool(const std::string& poolName)
 {
-  pools_t::const_iterator it = pools.find(poolName);
-
+  const auto& pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+  auto it = pools.find(poolName);
   if (it == pools.end()) {
     throw std::out_of_range("No pool named " + poolName);
   }
diff --git a/pdns/dnsdistdist/dnsdist-lbpolicies.hh b/pdns/dnsdistdist/dnsdist-lbpolicies.hh
index fd943b2498..c609536959 100644
--- a/pdns/dnsdistdist/dnsdist-lbpolicies.hh
+++ b/pdns/dnsdistdist/dnsdist-lbpolicies.hh
@@ -35,8 +35,8 @@ public:
   template <class T>
   using NumberedVector = std::vector<std::pair<unsigned int, T>>;
   using NumberedServerVector = NumberedVector<shared_ptr<DownstreamState>>;
-  typedef std::function<shared_ptr<DownstreamState>(const NumberedServerVector& servers, const DNSQuestion*)> policyfunc_t;
-  typedef std::function<unsigned int(dnsdist_ffi_servers_list_t* servers, dnsdist_ffi_dnsquestion_t* dq)> ffipolicyfunc_t;
+  using policyfunc_t = std::function<std::shared_ptr<DownstreamState>(const NumberedServerVector& servers, const DNSQuestion*)>;
+  using ffipolicyfunc_t = std::function<unsigned int(dnsdist_ffi_servers_list_t* servers, dnsdist_ffi_dnsquestion_t* dq)>;
 
   ServerPolicy(const std::string& name_, policyfunc_t policy_, bool isLua_) :
     d_name(name_), d_policy(std::move(policy_)), d_isLua(isLua_)
@@ -92,14 +92,14 @@ public:
 
 struct ServerPool;
 
-using pools_t = map<std::string, std::shared_ptr<ServerPool>>;
-std::shared_ptr<ServerPool> getPool(const pools_t& pools, const std::string& poolName);
-std::shared_ptr<ServerPool> createPoolIfNotExists(pools_t& pools, const string& poolName);
-void setPoolPolicy(pools_t& pools, const string& poolName, std::shared_ptr<ServerPolicy> policy);
-void addServerToPool(pools_t& pools, const string& poolName, std::shared_ptr<DownstreamState> server);
-void removeServerFromPool(pools_t& pools, const string& poolName, std::shared_ptr<DownstreamState> server);
+using pools_t = std::map<std::string, std::shared_ptr<ServerPool>>;
+std::shared_ptr<ServerPool> getPool(const std::string& poolName);
+std::shared_ptr<ServerPool> createPoolIfNotExists(const string& poolName);
+void setPoolPolicy(const string& poolName, std::shared_ptr<ServerPolicy> policy);
+void addServerToPool(const string& poolName, std::shared_ptr<DownstreamState> server);
+void removeServerFromPool(const string& poolName, std::shared_ptr<DownstreamState> server);
 
-const std::shared_ptr<const ServerPolicy::NumberedServerVector> getDownstreamCandidates(const map<std::string, std::shared_ptr<ServerPool>>& pools, const std::string& poolName);
+const std::shared_ptr<const ServerPolicy::NumberedServerVector> getDownstreamCandidates(const std::string& poolName);
 
 std::shared_ptr<DownstreamState> firstAvailable(const ServerPolicy::NumberedServerVector& servers, const DNSQuestion* dq);
 
diff --git a/pdns/dnsdistdist/dnsdist-lua-bindings.cc b/pdns/dnsdistdist/dnsdist-lua-bindings.cc
index 7681f70248..3cadf14b2a 100644
--- a/pdns/dnsdistdist/dnsdist-lua-bindings.cc
+++ b/pdns/dnsdistdist/dnsdist-lua-bindings.cc
@@ -116,15 +116,11 @@ 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) {
-    auto localPools = g_pools.getCopy();
-    addServerToPool(localPools, pool, state);
-    g_pools.setState(localPools);
+    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) {
-    auto localPools = g_pools.getCopy();
-    removeServerFromPool(localPools, pool, state);
-    g_pools.setState(localPools);
+    removeServerFromPool(pool, state);
     state->d_config.pools.erase(pool);
   });
   luaCtx.registerFunction<uint64_t (DownstreamState::*)() const>("getOutstanding", [](const DownstreamState& state) { return state.outstanding.load(); });
diff --git a/pdns/dnsdistdist/dnsdist-lua-ffi.cc b/pdns/dnsdistdist/dnsdist-lua-ffi.cc
index 1b849cefb6..bb2b518f92 100644
--- a/pdns/dnsdistdist/dnsdist-lua-ffi.cc
+++ b/pdns/dnsdistdist/dnsdist-lua-ffi.cc
@@ -1161,9 +1161,9 @@ size_t dnsdist_ffi_packetcache_get_domain_list_by_addr(const char* poolName, con
     return 0;
   }
 
-  const auto localPools = g_pools.getCopy();
-  auto it = localPools.find(poolName);
-  if (it == localPools.end()) {
+  const auto& pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+  auto it = pools.find(poolName);
+  if (it == pools.end()) {
     return 0;
   }
 
@@ -1210,9 +1210,9 @@ size_t dnsdist_ffi_packetcache_get_address_list_by_domain(const char* poolName,
     return 0;
   }
 
-  const auto localPools = g_pools.getCopy();
-  auto it = localPools.find(poolName);
-  if (it == localPools.end()) {
+  const auto& pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+  auto it = pools.find(poolName);
+  if (it == pools.end()) {
     return 0;
   }
 
diff --git a/pdns/dnsdistdist/dnsdist-lua.cc b/pdns/dnsdistdist/dnsdist-lua.cc
index 096d0335c7..57ecdd8673 100644
--- a/pdns/dnsdistdist/dnsdist-lua.cc
+++ b/pdns/dnsdistdist/dnsdist-lua.cc
@@ -689,16 +689,14 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
 
                          /* this needs to be done _AFTER_ the order has been set,
                             since the server are kept ordered inside the pool */
-                         auto localPools = g_pools.getCopy();
                          if (!ret->d_config.pools.empty()) {
                            for (const auto& poolName : ret->d_config.pools) {
-                             addServerToPool(localPools, poolName, ret);
+                             addServerToPool(poolName, ret);
                            }
                          }
                          else {
-                           addServerToPool(localPools, "", ret);
+                           addServerToPool("", ret);
                          }
-                         g_pools.setState(localPools);
 
                          if (ret->connected) {
                            if (g_launchWork) {
@@ -744,13 +742,11 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
                          if (!server) {
                            throw std::runtime_error("unable to locate the requested server");
                          }
-                         auto localPools = g_pools.getCopy();
                          for (const string& poolName : server->d_config.pools) {
-                           removeServerFromPool(localPools, poolName, server);
+                           removeServerFromPool(poolName, server);
                          }
                          /* the server might also be in the default pool */
-                         removeServerFromPool(localPools, "", server);
-                         g_pools.setState(localPools);
+                         removeServerFromPool("", server);
                          states.erase(remove(states.begin(), states.end(), server), states.end());
                          g_dstates.setState(states);
                          server->stop();
@@ -1238,7 +1234,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
   });
 
   luaCtx.writeFunction("getPoolServers", [](const string& pool) {
-    const auto poolServers = getDownstreamCandidates(g_pools.getCopy(), pool);
+    const auto poolServers = getDownstreamCandidates(pool);
     return *poolServers;
   });
 
@@ -1865,12 +1861,13 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       //             1        2         3                4
       ret << (fmt % "Name" % "Cache" % "ServerPolicy" % "Servers") << endl;
 
-      const auto localPools = g_pools.getCopy();
-      for (const auto& entry : localPools) {
+      const auto defaultPolicyName = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy->getName();
+      const auto pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+      for (const auto& entry : pools) {
         const string& name = entry.first;
         const std::shared_ptr<ServerPool> pool = entry.second;
         string cache = pool->packetCache != nullptr ? pool->packetCache->toString() : "";
-        string policy = g_policy.getLocal()->getName();
+        string policy = defaultPolicyName;
         if (pool->policy != nullptr) {
           policy = pool->policy->getName();
         }
@@ -1902,8 +1899,8 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     setLuaNoSideEffect();
     LuaArray<std::string> ret;
     int count = 1;
-    const auto localPools = g_pools.getCopy();
-    for (const auto& entry : localPools) {
+    const auto pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+    for (const auto& entry : pools) {
       const string& name = entry.first;
       ret.emplace_back(count++, name);
     }
@@ -1914,9 +1911,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     if (client) {
       return std::make_shared<ServerPool>();
     }
-    auto localPools = g_pools.getCopy();
-    std::shared_ptr<ServerPool> pool = createPoolIfNotExists(localPools, poolName);
-    g_pools.setState(localPools);
+    std::shared_ptr<ServerPool> pool = createPoolIfNotExists(poolName);
     return pool;
   });
 
@@ -2256,65 +2251,65 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
 #ifndef DISABLE_POLICIES_BINDINGS
   luaCtx.writeFunction("setServerPolicy", [](const std::shared_ptr<ServerPolicy>& policy) {
     setLuaSideEffect();
-    g_policy.setState(*policy);
+    dnsdist::configuration::updateRuntimeConfiguration([&policy](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = policy;
+    });
   });
 
   luaCtx.writeFunction("setServerPolicyLua", [](const string& name, ServerPolicy::policyfunc_t policy) {
     setLuaSideEffect();
-    g_policy.setState(ServerPolicy{name, std::move(policy), true});
+    auto pol = std::make_shared<ServerPolicy>(name, std::move(policy), true);
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
 
   luaCtx.writeFunction("setServerPolicyLuaFFI", [](const string& name, ServerPolicy::ffipolicyfunc_t policy) {
     setLuaSideEffect();
-    auto pol = ServerPolicy(name, std::move(policy));
-    g_policy.setState(std::move(pol));
+    auto pol = std::make_shared<ServerPolicy>(name, std::move(policy));
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
 
   luaCtx.writeFunction("setServerPolicyLuaFFIPerThread", [](const string& name, const std::string& policyCode) {
     setLuaSideEffect();
-    auto pol = ServerPolicy(name, policyCode);
-    g_policy.setState(std::move(pol));
+    auto policy = std::make_shared<ServerPolicy>(name, policyCode);
+    dnsdist::configuration::updateRuntimeConfiguration([&policy](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(policy);
+    });
   });
 
   luaCtx.writeFunction("showServerPolicy", []() {
     setLuaSideEffect();
-    g_outputBuffer = g_policy.getLocal()->getName() + "\n";
+    g_outputBuffer = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy->getName() + "\n";
   });
 
   luaCtx.writeFunction("setPoolServerPolicy", [](const std::shared_ptr<ServerPolicy>& policy, const string& pool) {
     setLuaSideEffect();
-    auto localPools = g_pools.getCopy();
-    setPoolPolicy(localPools, pool, policy);
-    g_pools.setState(localPools);
+    setPoolPolicy(pool, policy);
   });
 
   luaCtx.writeFunction("setPoolServerPolicyLua", [](const string& name, ServerPolicy::policyfunc_t policy, const string& pool) {
     setLuaSideEffect();
-    auto localPools = g_pools.getCopy();
-    setPoolPolicy(localPools, pool, std::make_shared<ServerPolicy>(ServerPolicy{name, std::move(policy), true}));
-    g_pools.setState(localPools);
+    setPoolPolicy(pool, std::make_shared<ServerPolicy>(ServerPolicy{name, std::move(policy), true}));
   });
 
   luaCtx.writeFunction("setPoolServerPolicyLuaFFI", [](const string& name, ServerPolicy::ffipolicyfunc_t policy, const string& pool) {
     setLuaSideEffect();
-    auto localPools = g_pools.getCopy();
-    setPoolPolicy(localPools, pool, std::make_shared<ServerPolicy>(ServerPolicy{name, std::move(policy)}));
-    g_pools.setState(localPools);
+    setPoolPolicy(pool, std::make_shared<ServerPolicy>(ServerPolicy{name, std::move(policy)}));
   });
 
   luaCtx.writeFunction("setPoolServerPolicyLuaFFIPerThread", [](const string& name, const std::string& policyCode, const std::string& pool) {
     setLuaSideEffect();
-    auto localPools = g_pools.getCopy();
-    setPoolPolicy(localPools, pool, std::make_shared<ServerPolicy>(ServerPolicy{name, policyCode}));
-    g_pools.setState(localPools);
+    setPoolPolicy(pool, std::make_shared<ServerPolicy>(ServerPolicy{name, policyCode}));
   });
 
   luaCtx.writeFunction("showPoolServerPolicy", [](const std::string& pool) {
     setLuaSideEffect();
-    auto localPools = g_pools.getCopy();
-    auto poolObj = getPool(localPools, pool);
+    auto poolObj = getPool(pool);
     if (poolObj->policy == nullptr) {
-      g_outputBuffer = g_policy.getLocal()->getName() + "\n";
+      g_outputBuffer = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy->getName() + "\n";
     }
     else {
       g_outputBuffer = poolObj->policy->getName() + "\n";
diff --git a/pdns/dnsdistdist/dnsdist-rules.hh b/pdns/dnsdistdist/dnsdist-rules.hh
index d0f2fcb70d..ac136968a4 100644
--- a/pdns/dnsdistdist/dnsdist-rules.hh
+++ b/pdns/dnsdistdist/dnsdist-rules.hh
@@ -1104,13 +1104,13 @@ private:
 class PoolAvailableRule : public DNSRule
 {
 public:
-  PoolAvailableRule(const std::string& poolname) : d_pools(&g_pools), d_poolname(poolname)
+  PoolAvailableRule(const std::string& poolname) : d_poolname(poolname)
   {
   }
 
   bool matches(const DNSQuestion* dq) const override
   {
-    return (getPool(*d_pools, d_poolname)->countServers(true) > 0);
+    return (getPool(d_poolname)->countServers(true) > 0);
   }
 
   string toString() const override
@@ -1118,20 +1118,19 @@ public:
     return "pool '" + d_poolname + "' is available";
   }
 private:
-  mutable LocalStateHolder<pools_t> d_pools;
   std::string d_poolname;
 };
 
 class PoolOutstandingRule : public DNSRule
 {
 public:
-  PoolOutstandingRule(const std::string& poolname, const size_t limit) : d_pools(&g_pools), d_poolname(poolname), d_limit(limit)
+  PoolOutstandingRule(const std::string& poolname, const size_t limit) : d_poolname(poolname), d_limit(limit)
   {
   }
 
   bool matches(const DNSQuestion* dq) const override
   {
-    return (getPool(*d_pools, d_poolname)->poolLoad()) > d_limit;
+    return (getPool(d_poolname)->poolLoad()) > d_limit;
   }
 
   string toString() const override
@@ -1139,7 +1138,6 @@ public:
     return "pool '" + d_poolname + "' outstanding > " + std::to_string(d_limit);
   }
 private:
-  mutable LocalStateHolder<pools_t> d_pools;
   std::string d_poolname;
   size_t d_limit;
 };
diff --git a/pdns/dnsdistdist/dnsdist-web.cc b/pdns/dnsdistdist/dnsdist-web.cc
index 26c77b2837..02e3feda0a 100644
--- a/pdns/dnsdistdist/dnsdist-web.cc
+++ b/pdns/dnsdistdist/dnsdist-web.cc
@@ -842,7 +842,6 @@ static void handlePrometheus(const YaHTTP::Request& req, YaHTTP::Response& resp)
   }
 #endif /* HAVE_DNS_OVER_HTTPS */
 
-  auto localPools = g_pools.getLocal();
   const string cachebase = "dnsdist_pool_";
   output << "# HELP dnsdist_pool_servers " << "Number of servers in that pool" << "\n";
   output << "# TYPE dnsdist_pool_servers " << "gauge" << "\n";
@@ -870,7 +869,7 @@ static void handlePrometheus(const YaHTTP::Request& req, YaHTTP::Response& resp)
   output << "# HELP dnsdist_pool_cache_cleanup_count_total " << "Number of times the cache has been scanned to remove expired entries, if any" << "\n";
   output << "# TYPE dnsdist_pool_cache_cleanup_count_total " << "counter" << "\n";
 
-  for (const auto& entry : *localPools) {
+  for (const auto& entry : dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools) {
     string poolName = entry.first;
 
     if (poolName.empty()) {
@@ -980,7 +979,7 @@ static void handleJSONStats(const YaHTTP::Request& req, YaHTTP::Response& resp)
       {"packetcache-misses", 0},
       {"over-capacity-drops", 0},
       {"too-old-drops", 0},
-      {"server-policy", g_policy.getLocal()->getName()}};
+      {"server-policy", runtimeConfig.d_lbPolicy->getName()}};
 
     addStatsToJSONObject(obj);
 
@@ -1252,10 +1251,10 @@ static void handleStats(const YaHTTP::Request& req, YaHTTP::Response& resp)
 
   Json::array pools;
   {
-    auto localPools = g_pools.getLocal();
     num = 0;
-    pools.reserve(localPools->size());
-    for (const auto& pool : *localPools) {
+    const auto localPools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+    pools.reserve(localPools.size());
+    for (const auto& pool : localPools) {
       const auto& cache = pool.second->packetCache;
       Json::object entry{
         {"id", num++},
@@ -1357,9 +1356,9 @@ static void handlePoolStats(const YaHTTP::Request& req, YaHTTP::Response& resp)
   resp.status = 200;
   Json::array doc;
 
-  auto localPools = g_pools.getLocal();
-  const auto poolIt = localPools->find(poolName->second);
-  if (poolIt == localPools->end()) {
+  const auto& pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+  const auto poolIt = pools.find(poolName->second);
+  if (poolIt == pools.end()) {
     resp.status = 404;
     return;
   }
@@ -1458,7 +1457,7 @@ static void handleConfigDump(const YaHTTP::Request& req, YaHTTP::Response& resp)
     {"ecs-source-prefix-v6", static_cast<double>(runtimeConfiguration.d_ECSSourcePrefixV6)},
     {"fixup-case", runtimeConfiguration.d_fixupCase},
     {"max-outstanding", static_cast<double>(immutableConfig.d_maxUDPOutstanding)},
-    {"server-policy", g_policy.getLocal()->getName()},
+    {"server-policy", runtimeConfiguration.d_lbPolicy->getName()},
     {"stale-cache-entries-ttl", static_cast<double>(runtimeConfiguration.d_staleCacheEntriesTTL)},
     {"tcp-recv-timeout", static_cast<double>(runtimeConfiguration.d_tcpRecvTimeout)},
     {"tcp-send-timeout", static_cast<double>(runtimeConfiguration.d_tcpSendTimeout)},
@@ -1596,7 +1595,7 @@ static void handleCacheManagement(const YaHTTP::Request& req, YaHTTP::Response&
 
   std::shared_ptr<ServerPool> pool;
   try {
-    pool = getPool(g_pools.getCopy(), poolName->second);
+    pool = getPool(poolName->second);
   }
   catch (const std::exception& e) {
     resp.status = 404;
diff --git a/pdns/dnsdistdist/dnsdist.cc b/pdns/dnsdistdist/dnsdist.cc
index 3ed0cba99d..b28019f33d 100644
--- a/pdns/dnsdistdist/dnsdist.cc
+++ b/pdns/dnsdistdist/dnsdist.cc
@@ -105,7 +105,6 @@ shared_ptr<BPFFilter> g_defaultBPFFilter{nullptr};
 std::vector<std::shared_ptr<DynBPFFilter>> g_dynBPFFilters;
 
 std::vector<std::unique_ptr<ClientState>> g_frontends;
-GlobalStateHolder<pools_t> g_pools;
 std::vector<uint32_t> g_TCPFastOpenKey;
 /* UDP: the grand design. Per socket we listen on for incoming queries there is one thread.
    Then we have a bunch of connected sockets for talking to downstream servers.
@@ -1435,10 +1434,10 @@ static ProcessQueryResult handleQueryTurnedIntoSelfAnsweredResponse(DNSQuestion&
   return ProcessQueryResult::SendAnswer;
 }
 
-static void selectBackendForOutgoingQuery(DNSQuestion& dnsQuestion, const std::shared_ptr<ServerPool>& serverPool, LocalHolders& holders, std::shared_ptr<DownstreamState>& selectedBackend)
+static void selectBackendForOutgoingQuery(DNSQuestion& dnsQuestion, const std::shared_ptr<ServerPool>& serverPool, std::shared_ptr<DownstreamState>& selectedBackend)
 {
   std::shared_ptr<ServerPolicy> poolPolicy = serverPool->policy;
-  const auto& policy = poolPolicy != nullptr ? *poolPolicy : *(holders.policy);
+  const auto& policy = poolPolicy != nullptr ? *poolPolicy : *dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy;
   const auto servers = serverPool->getServers();
   selectedBackend = policy.getSelectedBackend(*servers, dnsQuestion);
 }
@@ -1451,9 +1450,9 @@ ProcessQueryResult processQueryAfterRules(DNSQuestion& dnsQuestion, LocalHolders
     if (dnsQuestion.getHeader()->qr) { // something turned it into a response
       return handleQueryTurnedIntoSelfAnsweredResponse(dnsQuestion, holders);
     }
-    std::shared_ptr<ServerPool> serverPool = getPool(*holders.pools, dnsQuestion.ids.poolName);
+    std::shared_ptr<ServerPool> serverPool = getPool(dnsQuestion.ids.poolName);
     dnsQuestion.ids.packetCache = serverPool->packetCache;
-    selectBackendForOutgoingQuery(dnsQuestion, serverPool, holders, selectedBackend);
+    selectBackendForOutgoingQuery(dnsQuestion, serverPool, selectedBackend);
 
     uint32_t allowExpired = selectedBackend ? 0 : dnsdist::configuration::getCurrentRuntimeConfiguration().d_staleCacheEntriesTTL;
 
@@ -1543,9 +1542,9 @@ ProcessQueryResult processQueryAfterRules(DNSQuestion& dnsQuestion, LocalHolders
       /* let's be nice and allow the selection of a different pool,
          but no second cache-lookup for you */
       if (dnsQuestion.ids.poolName != existingPool) {
-        serverPool = getPool(*holders.pools, dnsQuestion.ids.poolName);
+        serverPool = getPool(dnsQuestion.ids.poolName);
         dnsQuestion.ids.packetCache = serverPool->packetCache;
-        selectBackendForOutgoingQuery(dnsQuestion, serverPool, holders, selectedBackend);
+        selectBackendForOutgoingQuery(dnsQuestion, serverPool, selectedBackend);
       }
     }
 
@@ -2286,8 +2285,8 @@ static void maintThread()
 
       /* gather all caches actually used by at least one pool, and see
          if something prevents us from cleaning the expired entries */
-      auto localPools = g_pools.getLocal();
-      for (const auto& entry : *localPools) {
+      const auto& pools = dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools;
+      for (const auto& entry : pools) {
         const auto& pool = entry.second;
 
         auto packetCache = pool->packetCache;
@@ -2791,8 +2790,10 @@ static void cleanupLuaObjects()
     chain.holder.setState({});
   }
   g_dstates.setState({});
-  g_policy.setState(ServerPolicy());
-  g_pools.setState({});
+  dnsdist::configuration::updateRuntimeConfiguration([](dnsdist::configuration::RuntimeConfiguration& config) {
+    config.d_lbPolicy = std::make_shared<ServerPolicy>();
+    config.d_pools.clear();
+  });
   clearWebHandlers();
   dnsdist::lua::hooks::clearMaintenanceHooks();
 }
@@ -3047,31 +3048,28 @@ static void parseParameters(int argc, char** argv, ComboAddress& clientAddress)
 }
 static void setupPools()
 {
-  auto pools = g_pools.getCopy();
-  {
-    bool precompute = false;
-    if (g_policy.getLocal()->getName() == "chashed") {
-      precompute = true;
-    }
-    else {
-      for (const auto& entry : pools) {
-        if (entry.second->policy != nullptr && entry.second->policy->getName() == "chashed") {
-          precompute = true;
-          break;
-        }
+  bool precompute = false;
+  if (dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy->getName() == "chashed") {
+    precompute = true;
+  }
+  else {
+    for (const auto& entry : dnsdist::configuration::getCurrentRuntimeConfiguration().d_pools) {
+      if (entry.second->policy != nullptr && entry.second->policy->getName() == "chashed") {
+        precompute = true;
+        break;
       }
     }
-    if (precompute) {
-      vinfolog("Pre-computing hashes for consistent hash load-balancing policy");
-      // pre compute hashes
-      auto backends = g_dstates.getLocal();
-      for (const auto& backend : *backends) {
-        if (backend->d_config.d_weight < 100) {
-          vinfolog("Warning, the backend '%s' has a very low weight (%d), which will not yield a good distribution of queries with the 'chashed' policy. Please consider raising it to at least '100'.", backend->getName(), backend->d_config.d_weight);
-        }
-
-        backend->hash();
+  }
+  if (precompute) {
+    vinfolog("Pre-computing hashes for consistent hash load-balancing policy");
+    // pre compute hashes
+    auto backends = g_dstates.getLocal();
+    for (const auto& backend : *backends) {
+      if (backend->d_config.d_weight < 100) {
+        vinfolog("Warning, the backend '%s' has a very low weight (%d), which will not yield a good distribution of queries with the 'chashed' policy. Please consider raising it to at least '100'.", backend->getName(), backend->d_config.d_weight);
       }
+
+      backend->hash();
     }
   }
 }
@@ -3293,9 +3291,10 @@ int main(int argc, char** argv)
 
     parseParameters(argc, argv, clientAddress);
 
-    ServerPolicy leastOutstandingPol{"leastOutstanding", leastOutstanding, false};
+    dnsdist::configuration::updateRuntimeConfiguration([](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::make_shared<ServerPolicy>("leastOutstanding", leastOutstanding, false);
+    });
 
-    g_policy.setState(leastOutstandingPol);
     if (g_cmdLine.beClient || !g_cmdLine.command.empty()) {
       setupLua(*(g_lua.lock()), true, false, g_cmdLine.config);
       if (clientAddress != ComboAddress()) {
@@ -3428,20 +3427,18 @@ int main(int argc, char** argv)
       todoItem();
     }
 
-    auto localPools = g_pools.getCopy();
     /* create the default pool no matter what */
-    createPoolIfNotExists(localPools, "");
+    createPoolIfNotExists("");
     if (!g_cmdLine.remotes.empty()) {
       for (const auto& address : g_cmdLine.remotes) {
         DownstreamState::Config config;
         config.remote = ComboAddress(address, 53);
         auto ret = std::make_shared<DownstreamState>(std::move(config), nullptr, true);
-        addServerToPool(localPools, "", ret);
+        addServerToPool("", ret);
         ret->start();
         g_dstates.modify([&ret](servers_t& servers) { servers.push_back(std::move(ret)); });
       }
     }
-    g_pools.setState(localPools);
 
     if (g_dstates.getLocal()->empty()) {
       errlog("No downstream servers defined: all packets will get dropped");
diff --git a/pdns/dnsdistdist/dnsdist.hh b/pdns/dnsdistdist/dnsdist.hh
index 4cdad4bf52..8400b4825d 100644
--- a/pdns/dnsdistdist/dnsdist.hh
+++ b/pdns/dnsdistdist/dnsdist.hh
@@ -1026,9 +1026,7 @@ enum ednsHeaderFlags
 
 extern GlobalStateHolder<SuffixMatchTree<DynBlock>> g_dynblockSMT;
 
-extern GlobalStateHolder<ServerPolicy> g_policy;
 extern GlobalStateHolder<servers_t> g_dstates;
-extern GlobalStateHolder<pools_t> g_pools;
 
 extern std::vector<shared_ptr<TLSFrontend>> g_tlslocals;
 extern std::vector<shared_ptr<DOHFrontend>> g_dohlocals;
@@ -1067,11 +1065,10 @@ enum class ProcessQueryResult : uint8_t
 struct LocalHolders
 {
   LocalHolders() :
-    policy(g_policy.getLocal()), ruleactions(dnsdist::rules::getRuleChainHolder(dnsdist::rules::RuleChain::Rules).getLocal()), cacheMissRuleActions(dnsdist::rules::getRuleChainHolder(dnsdist::rules::RuleChain::CacheMissRules).getLocal()), cacheHitRespRuleactions(dnsdist::rules::getResponseRuleChainHolder(dnsdist::rules::ResponseRuleChain::CacheHitResponseRules).getLocal()), cacheInsertedRespRuleActions(dnsdist::rules::getResponseRuleChainHolder(dnsdist::rules::ResponseRuleChain::CacheInsertedResponseRules).getLocal()), selfAnsweredRespRuleactions(dnsdist::rules::getResponseRuleChainHolder(dnsdist::rules::ResponseRuleChain::SelfAnsweredResponseRules).getLocal()), servers(g_dstates.getLocal()), dynNMGBlock(g_dynblockNMG.getLocal()), dynSMTBlock(g_dynblockSMT.getLocal()), pools(g_pools.getLocal())
+    ruleactions(dnsdist::rules::getRuleChainHolder(dnsdist::rules::RuleChain::Rules).getLocal()), cacheMissRuleActions(dnsdist::rules::getRuleChainHolder(dnsdist::rules::RuleChain::CacheMissRules).getLocal()), cacheHitRespRuleactions(dnsdist::rules::getResponseRuleChainHolder(dnsdist::rules::ResponseRuleChain::CacheHitResponseRules).getLocal()), cacheInsertedRespRuleActions(dnsdist::rules::getResponseRuleChainHolder(dnsdist::rules::ResponseRuleChain::CacheInsertedResponseRules).getLocal()), selfAnsweredRespRuleactions(dnsdist::rules::getResponseRuleChainHolder(dnsdist::rules::ResponseRuleChain::SelfAnsweredResponseRules).getLocal()), servers(g_dstates.getLocal()), dynNMGBlock(g_dynblockNMG.getLocal()), dynSMTBlock(g_dynblockSMT.getLocal())
   {
   }
 
-  LocalStateHolder<ServerPolicy> policy;
   LocalStateHolder<vector<dnsdist::rules::RuleAction>> ruleactions;
   LocalStateHolder<vector<dnsdist::rules::RuleAction>> cacheMissRuleActions;
   LocalStateHolder<vector<dnsdist::rules::ResponseRuleAction>> cacheHitRespRuleactions;
@@ -1080,7 +1077,6 @@ struct LocalHolders
   LocalStateHolder<servers_t> servers;
   LocalStateHolder<NetmaskTree<DynBlock, AddressAndPortRange>> dynNMGBlock;
   LocalStateHolder<SuffixMatchTree<DynBlock>> dynSMTBlock;
-  LocalStateHolder<pools_t> pools;
 };
 
 ProcessQueryResult processQuery(DNSQuestion& dnsQuestion, LocalHolders& holders, std::shared_ptr<DownstreamState>& selectedBackend);
diff --git a/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc b/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc
index 6163e1aead..a412bd2e5d 100644
--- a/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc
+++ b/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc
@@ -474,10 +474,10 @@ BOOST_AUTO_TEST_CASE(test_PacketCache)
   testPool->packetCache = packetCache;
   std::string poolWithNoCacheName("test-pool-without-cache");
   auto testPoolWithNoCache = std::make_shared<ServerPool>();
-  auto localPools = g_pools.getCopy();
-  localPools.emplace(poolName, testPool);
-  localPools.emplace(poolWithNoCacheName, testPoolWithNoCache);
-  g_pools.setState(localPools);
+  dnsdist::configuration::updateRuntimeConfiguration([&poolName,&testPool,&poolWithNoCacheName,&testPoolWithNoCache](dnsdist::configuration::RuntimeConfiguration& config) {
+    config.d_pools.emplace(poolName, testPool);
+    config.d_pools.emplace(poolWithNoCacheName, testPoolWithNoCache);
+  });
 
   {
     dnsdist_ffi_domain_list_t* list = nullptr;
diff --git a/pdns/dnsdistdist/test-dnsdistlbpolicies_cc.cc b/pdns/dnsdistdist/test-dnsdistlbpolicies_cc.cc
index a3df9eff6a..05a6f6a67a 100644
--- a/pdns/dnsdistdist/test-dnsdistlbpolicies_cc.cc
+++ b/pdns/dnsdistdist/test-dnsdistlbpolicies_cc.cc
@@ -25,7 +25,6 @@ GlobalStateHolder<NetmaskTree<DynBlock>> g_dynblockNMG;
 GlobalStateHolder<SuffixMatchTree<DynBlock>> g_dynblockSMT;
 #endif /* BENCH_POLICIES */
 
-GlobalStateHolder<pools_t> g_pools;
 std::vector<std::unique_ptr<ClientState>> g_frontends;
 
 /* add stub implementations, we don't want to include the corresponding object files
@@ -129,12 +128,17 @@ static void resetLuaContext()
 {
   /* we need to reset this before cleaning the Lua state because the server policy might holds
      a reference to a Lua function (Lua policies) */
-  g_policy.setState(ServerPolicy("leastOutstanding", leastOutstanding, false));
+  dnsdist::configuration::updateRuntimeConfiguration([](dnsdist::configuration::RuntimeConfiguration& config) {
+    config.d_lbPolicy = std::make_shared<ServerPolicy>("leastOutstanding", leastOutstanding, false);
+  });
+  /* we actually need this line to clear the cached state for this thread */
+  BOOST_REQUIRE_EQUAL(dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy->getName(), "leastOutstanding");
   *(g_lua.lock()) = LuaContext();
 }
 
 BOOST_AUTO_TEST_SUITE(dnsdistlbpolicies)
 
+#if 0
 BOOST_AUTO_TEST_CASE(test_firstAvailable)
 {
   auto dnsQuestion = getDQ();
@@ -552,6 +556,7 @@ BOOST_AUTO_TEST_CASE(test_chashed)
     config.d_verbose = existingVerboseValue;
   });
 }
+#endif
 
 BOOST_AUTO_TEST_CASE(test_lua)
 {
@@ -572,12 +577,17 @@ BOOST_AUTO_TEST_CASE(test_lua)
   )foo";
   resetLuaContext();
   g_lua.lock()->writeFunction("setServerPolicyLua", [](const string& name, const ServerPolicy::policyfunc_t& policy) {
-    g_policy.setState(ServerPolicy{name, policy, true});
+    auto pol = std::make_shared<ServerPolicy>(name, std::move(policy), true);
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
   g_lua.lock()->executeCode(policySetupStr);
 
   {
-    ServerPolicy pol = g_policy.getCopy();
+    const auto& pol = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy;
+    BOOST_REQUIRE(pol != nullptr);
+    BOOST_REQUIRE(pol != nullptr);
     ServerPolicy::NumberedServerVector servers;
     std::map<std::shared_ptr<DownstreamState>, uint64_t> serversMap;
     for (size_t idx = 1; idx <= 10; idx++) {
@@ -589,7 +599,7 @@ BOOST_AUTO_TEST_CASE(test_lua)
 
     for (const auto& name : names) {
       auto dnsQuestion = getDQ(&name);
-      auto server = pol.getSelectedBackend(servers, dnsQuestion);
+      auto server = pol->getSelectedBackend(servers, dnsQuestion);
       BOOST_REQUIRE(serversMap.count(server) == 1);
       ++serversMap[server];
     }
@@ -603,11 +613,11 @@ BOOST_AUTO_TEST_CASE(test_lua)
     }
     BOOST_CHECK_EQUAL(total, names.size());
 
-    benchPolicy(pol);
+    benchPolicy(*pol);
   }
   resetLuaContext();
 }
-
+#if 0
 #ifdef LUAJIT_VERSION
 
 BOOST_AUTO_TEST_CASE(test_lua_ffi_rr)
@@ -633,12 +643,16 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_rr)
   resetLuaContext();
   g_lua.lock()->executeCode(getLuaFFIWrappers());
   g_lua.lock()->writeFunction("setServerPolicyLuaFFI", [](const string& name, const ServerPolicy::ffipolicyfunc_t& policy) {
-    g_policy.setState(ServerPolicy(name, policy));
+    auto pol = std::make_shared<ServerPolicy>(name, std::move(policy));
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
   g_lua.lock()->executeCode(policySetupStr);
 
   {
-    ServerPolicy pol = g_policy.getCopy();
+    const auto& pol = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy;
+    BOOST_REQUIRE(pol != nullptr);
     ServerPolicy::NumberedServerVector servers;
     std::map<std::shared_ptr<DownstreamState>, uint64_t> serversMap;
     for (size_t idx = 1; idx <= 10; idx++) {
@@ -650,7 +664,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_rr)
 
     for (const auto& name : names) {
       auto dnsQuestion = getDQ(&name);
-      auto server = pol.getSelectedBackend(servers, dnsQuestion);
+      auto server = pol->getSelectedBackend(servers, dnsQuestion);
       BOOST_REQUIRE(serversMap.count(server) == 1);
       ++serversMap[server];
     }
@@ -664,7 +678,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_rr)
     }
     BOOST_CHECK_EQUAL(total, names.size());
 
-    benchPolicy(pol);
+    benchPolicy(*pol);
   }
   resetLuaContext();
 }
@@ -687,12 +701,16 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_no_server_available)
   resetLuaContext();
   g_lua.lock()->executeCode(getLuaFFIWrappers());
   g_lua.lock()->writeFunction("setServerPolicyLuaFFI", [](const string& policyName, ServerPolicy::ffipolicyfunc_t policy) {
-    g_policy.setState(ServerPolicy(policyName, std::move(policy)));
+    auto pol = std::make_shared<ServerPolicy>(policyName, std::move(policy));
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
   g_lua.lock()->executeCode(policySetupStr);
 
   {
-    ServerPolicy pol = g_policy.getCopy();
+    const auto& pol = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy;
+    BOOST_REQUIRE(pol != nullptr);
     ServerPolicy::NumberedServerVector servers;
     for (size_t idx = 1; idx <= 10; idx++) {
       servers.emplace_back(idx, std::make_shared<DownstreamState>(ComboAddress("192.0.2." + std::to_string(idx) + ":53")));
@@ -701,7 +719,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_no_server_available)
     BOOST_REQUIRE_EQUAL(servers.size(), 10U);
 
     auto dnsQuestion = getDQ(&dnsName);
-    auto server = pol.getSelectedBackend(servers, dnsQuestion);
+    auto server = pol->getSelectedBackend(servers, dnsQuestion);
     BOOST_REQUIRE(server == nullptr);
   }
   resetLuaContext();
@@ -729,12 +747,16 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_hashed)
   resetLuaContext();
   g_lua.lock()->executeCode(getLuaFFIWrappers());
   g_lua.lock()->writeFunction("setServerPolicyLuaFFI", [](const string& name, const ServerPolicy::ffipolicyfunc_t& policy) {
-    g_policy.setState(ServerPolicy(name, policy));
+    auto pol = std::make_shared<ServerPolicy>(name, std::move(policy));
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
   g_lua.lock()->executeCode(policySetupStr);
 
   {
-    ServerPolicy pol = g_policy.getCopy();
+    const auto& pol = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy;
+    BOOST_REQUIRE(pol != nullptr);
     ServerPolicy::NumberedServerVector servers;
     std::map<std::shared_ptr<DownstreamState>, uint64_t> serversMap;
     for (size_t idx = 1; idx <= 10; idx++) {
@@ -746,7 +768,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_hashed)
 
     for (const auto& name : names) {
       auto dnsQuestion = getDQ(&name);
-      auto server = pol.getSelectedBackend(servers, dnsQuestion);
+      auto server = pol->getSelectedBackend(servers, dnsQuestion);
       BOOST_REQUIRE(serversMap.count(server) == 1);
       ++serversMap[server];
     }
@@ -760,7 +782,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_hashed)
     }
     BOOST_CHECK_EQUAL(total, names.size());
 
-    benchPolicy(pol);
+    benchPolicy(*pol);
   }
   resetLuaContext();
 }
@@ -785,12 +807,16 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_whashed)
   resetLuaContext();
   g_lua.lock()->executeCode(getLuaFFIWrappers());
   g_lua.lock()->writeFunction("setServerPolicyLuaFFI", [](const string& name, const ServerPolicy::ffipolicyfunc_t& policy) {
-    g_policy.setState(ServerPolicy(name, policy));
+    auto pol = std::make_shared<ServerPolicy>(name, std::move(policy));
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
   g_lua.lock()->executeCode(policySetupStr);
 
   {
-    ServerPolicy pol = g_policy.getCopy();
+    const auto& pol = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy;
+    BOOST_REQUIRE(pol != nullptr);
     ServerPolicy::NumberedServerVector servers;
     std::map<std::shared_ptr<DownstreamState>, uint64_t> serversMap;
     for (size_t idx = 1; idx <= 10; idx++) {
@@ -802,7 +828,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_whashed)
 
     for (const auto& name : names) {
       auto dnsQuestion = getDQ(&name);
-      auto server = pol.getSelectedBackend(servers, dnsQuestion);
+      auto server = pol->getSelectedBackend(servers, dnsQuestion);
       BOOST_REQUIRE(serversMap.count(server) == 1);
       ++serversMap[server];
     }
@@ -816,7 +842,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_whashed)
     }
     BOOST_CHECK_EQUAL(total, names.size());
 
-    benchPolicy(pol);
+    benchPolicy(*pol);
   }
   resetLuaContext();
 }
@@ -841,12 +867,16 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_chashed)
   resetLuaContext();
   g_lua.lock()->executeCode(getLuaFFIWrappers());
   g_lua.lock()->writeFunction("setServerPolicyLuaFFI", [](const string& name, const ServerPolicy::ffipolicyfunc_t& policy) {
-    g_policy.setState(ServerPolicy(name, policy));
+    auto pol = std::make_shared<ServerPolicy>(name, std::move(policy));
+    dnsdist::configuration::updateRuntimeConfiguration([&pol](dnsdist::configuration::RuntimeConfiguration& config) {
+      config.d_lbPolicy = std::move(pol);
+    });
   });
   g_lua.lock()->executeCode(policySetupStr);
 
   {
-    ServerPolicy pol = g_policy.getCopy();
+    const auto& pol = dnsdist::configuration::getCurrentRuntimeConfiguration().d_lbPolicy;
+    BOOST_REQUIRE(pol != nullptr);
     ServerPolicy::NumberedServerVector servers;
     std::map<std::shared_ptr<DownstreamState>, uint64_t> serversMap;
     for (size_t idx = 1; idx <= 10; idx++) {
@@ -862,7 +892,7 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_chashed)
 
     for (const auto& name : names) {
       auto dnsQuestion = getDQ(&name);
-      auto server = pol.getSelectedBackend(servers, dnsQuestion);
+      auto server = pol->getSelectedBackend(servers, dnsQuestion);
       BOOST_REQUIRE(serversMap.count(server) == 1);
       ++serversMap[server];
     }
@@ -876,11 +906,11 @@ BOOST_AUTO_TEST_CASE(test_lua_ffi_chashed)
     }
     BOOST_CHECK_EQUAL(total, names.size());
 
-    benchPolicy(pol);
+    benchPolicy(*pol);
   }
   resetLuaContext();
 }
 
 #endif /* LUAJIT_VERSION */
-
+#endif
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/pdns/dnsdistdist/test-dnsdistrules_cc.cc b/pdns/dnsdistdist/test-dnsdistrules_cc.cc
index 8f7363a29e..0cda248317 100644
--- a/pdns/dnsdistdist/test-dnsdistrules_cc.cc
+++ b/pdns/dnsdistdist/test-dnsdistrules_cc.cc
@@ -145,10 +145,8 @@ BOOST_AUTO_TEST_CASE(test_poolOutstandingRule) {
 
   BOOST_CHECK_EQUAL(sp.poolLoad(), 400U + 30U);
 
-  auto localPool = g_pools.getCopy();
-  addServerToPool(localPool, "test", ds1);
-  addServerToPool(localPool, "test", ds2);
-  g_pools.setState(localPool);
+  addServerToPool("test", ds1);
+  addServerToPool("test", ds2);
 
   PoolOutstandingRule pOR1("test", 10);
   BOOST_CHECK_EQUAL(pOR1.matches(&dq), true);