From: Remi Gacogne Date: Thu, 13 Jun 2024 11:42:01 +0000 (+0200) Subject: dnsdist: Move Rings to the new configuration X-Git-Tag: rec-5.2.0-alpha1~172^2~9 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=f822e8f2ba723543dac9883d215f08fc89357ec5;p=thirdparty%2Fpdns.git dnsdist: Move Rings to the new configuration --- diff --git a/pdns/dnsdistdist/dnsdist-carbon.hh b/pdns/dnsdistdist/dnsdist-carbon.hh index e0162a69c3..96c9f96dac 100644 --- a/pdns/dnsdistdist/dnsdist-carbon.hh +++ b/pdns/dnsdistdist/dnsdist-carbon.hh @@ -43,7 +43,6 @@ public: static Endpoint newEndpoint(const std::string& address, std::string ourName, uint64_t interval, const std::string& namespace_name, const std::string& instance_name); static void run(const std::vector& endpoints); - static void addEndpointAtRuntime(const Endpoint& endpoint); }; } diff --git a/pdns/dnsdistdist/dnsdist-configuration.hh b/pdns/dnsdistdist/dnsdist-configuration.hh index c21845b567..a102fb6db5 100644 --- a/pdns/dnsdistdist/dnsdist-configuration.hh +++ b/pdns/dnsdistdist/dnsdist-configuration.hh @@ -27,6 +27,7 @@ #include #include +#include "config.h" #include "credentials.hh" #include "dnsdist-carbon.hh" #include "dnsdist-query-count.hh" @@ -182,6 +183,9 @@ struct Configuration uint64_t d_maxTCPClientThreads{0}; size_t d_maxTCPConnectionsPerClient{0}; size_t d_udpVectorSize{1}; + size_t d_ringsCapacity{10000}; + size_t d_ringsNumberOfShards{10}; + size_t d_ringsNbLockTries{5}; uint32_t d_socketUDPSendBuffer{0}; uint32_t d_socketUDPRecvBuffer{0}; uint32_t d_hashPerturbation{0}; @@ -189,6 +193,8 @@ struct Configuration uint8_t d_udpTimeout{2}; bool d_randomizeUDPSocketsToBackend{false}; bool d_randomizeIDsToBackend{false}; + bool d_ringsRecordQueries{true}; + bool d_ringsRecordResponses{true}; }; /* this part of the configuration can be updated at runtime via @@ -197,7 +203,9 @@ struct RuntimeConfiguration { rules::RuleChains d_ruleChains; servers_t d_backends; +#ifndef DISABLE_CARBON std::vector d_carbonEndpoints; +#endif /* DISABLE_CARBON */ std::map> d_pools; std::shared_ptr d_webPassword; std::shared_ptr d_webAPIKey; diff --git a/pdns/dnsdistdist/dnsdist-dynblocks.cc b/pdns/dnsdistdist/dnsdist-dynblocks.cc index 1891fb9a16..371a0f1194 100644 --- a/pdns/dnsdistdist/dnsdist-dynblocks.cc +++ b/pdns/dnsdistdist/dnsdist-dynblocks.cc @@ -3,10 +3,10 @@ #include "dnsdist-metrics.hh" #include "sholder.hh" +#ifndef DISABLE_DYNBLOCKS static GlobalStateHolder s_dynblockNMG; static GlobalStateHolder s_dynblockSMT; -#ifndef DISABLE_DYNBLOCKS void DynBlockRulesGroup::apply(const timespec& now) { counts_t counts; diff --git a/pdns/dnsdistdist/dnsdist-lua.cc b/pdns/dnsdistdist/dnsdist-lua.cc index 9ccd8c905f..3313a2f935 100644 --- a/pdns/dnsdistdist/dnsdist-lua.cc +++ b/pdns/dnsdistdist/dnsdist-lua.cc @@ -860,27 +860,29 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck) const std::function mutator; const size_t maximumValue{std::numeric_limits::max()}; }; - static const std::vector unsignedIntegerImmutableConfigItems{ + static const std::vector unsignedIntegerImmutableConfigItems + { {"setMaxTCPQueuedConnections", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_maxTCPQueuedConnections = newValue; }, std::numeric_limits::max()}, - {"setMaxTCPClientThreads", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_maxTCPClientThreads = newValue; }, std::numeric_limits::max()}, - {"setMaxTCPConnectionsPerClient", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_maxTCPConnectionsPerClient = newValue; }, std::numeric_limits::max()}, - {"setTCPInternalPipeBufferSize", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_tcpInternalPipeBufferSize = newValue; }, std::numeric_limits::max()}, - {"setMaxCachedTCPConnectionsPerDownstream", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdlePerBackend = newValue; }, std::numeric_limits::max()}, - {"setTCPDownstreamCleanupInterval", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingTCPCleanupInterval = newValue; }, std::numeric_limits::max()}, - {"setTCPDownstreamMaxIdleTime", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdleTime = newValue; }, std::numeric_limits::max()}, + {"setMaxTCPClientThreads", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_maxTCPClientThreads = newValue; }, std::numeric_limits::max()}, + {"setMaxTCPConnectionsPerClient", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_maxTCPConnectionsPerClient = newValue; }, std::numeric_limits::max()}, + {"setTCPInternalPipeBufferSize", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_tcpInternalPipeBufferSize = newValue; }, std::numeric_limits::max()}, + {"setMaxCachedTCPConnectionsPerDownstream", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdlePerBackend = newValue; }, std::numeric_limits::max()}, + {"setTCPDownstreamCleanupInterval", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingTCPCleanupInterval = newValue; }, std::numeric_limits::max()}, + {"setTCPDownstreamMaxIdleTime", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingTCPMaxIdleTime = newValue; }, std::numeric_limits::max()}, #if defined(HAVE_DNS_OVER_HTTPS) && defined(HAVE_NGHTTP2) - {"setOutgoingDoHWorkerThreads", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHWorkers = newValue; }, std::numeric_limits::max()}, - {"setMaxIdleDoHConnectionsPerDownstream", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdlePerBackend = newValue; }, std::numeric_limits::max()}, - {"setDoHDownstreamCleanupInterval", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHCleanupInterval = newValue; }, std::numeric_limits::max()}, - {"setDoHDownstreamMaxIdleTime", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdleTime = newValue; }, std::numeric_limits::max()}, + {"setOutgoingDoHWorkerThreads", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHWorkers = newValue; }, std::numeric_limits::max()}, + {"setMaxIdleDoHConnectionsPerDownstream", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdlePerBackend = newValue; }, std::numeric_limits::max()}, + {"setDoHDownstreamCleanupInterval", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHCleanupInterval = newValue; }, std::numeric_limits::max()}, + {"setDoHDownstreamMaxIdleTime", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_outgoingDoHMaxIdleTime = newValue; }, std::numeric_limits::max()}, #endif /* HAVE_DNS_OVER_HTTPS && HAVE_NGHTTP2 */ - {"setMaxUDPOutstanding", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_maxUDPOutstanding = newValue; }, std::numeric_limits::max()}, - {"setWHashedPertubation", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_hashPerturbation = newValue; }, std::numeric_limits::max()}, + {"setMaxUDPOutstanding", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_maxUDPOutstanding = newValue; }, std::numeric_limits::max()}, + {"setWHashedPertubation", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_hashPerturbation = newValue; }, std::numeric_limits::max()}, #ifndef DISABLE_RECVMMSG - {"setUDPMultipleMessagesVectorSize", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_udpVectorSize = newValue; }, std::numeric_limits::max()}, + {"setUDPMultipleMessagesVectorSize", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_udpVectorSize = newValue; }, std::numeric_limits::max()}, #endif /* DISABLE_RECVMMSG */ - {"setUDPTimeout", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_udpTimeout = newValue; }, std::numeric_limits::max()}, - {"setConsoleMaximumConcurrentConnections", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_consoleMaxConcurrentConnections = newValue; }, std::numeric_limits::max()}, + {"setUDPTimeout", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_udpTimeout = newValue; }, std::numeric_limits::max()}, + {"setConsoleMaximumConcurrentConnections", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_consoleMaxConcurrentConnections = newValue; }, std::numeric_limits::max()}, + {"setRingBuffersLockRetries", [](dnsdist::configuration::Configuration& config, uint64_t newValue) { config.d_ringsNbLockTries = newValue; }, std::numeric_limits::max()}, }; struct DoubleImmutableConfigurationItems @@ -2141,39 +2143,45 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck) }); luaCtx.writeFunction("setRingBuffersSize", [client](uint64_t capacity, boost::optional numberOfShards) { - setLuaSideEffect(); - if (!checkConfigurationTime("setRingBuffersSize")) { + if (client) { return; } - if (!client) { - g_rings.setCapacity(capacity, numberOfShards ? *numberOfShards : 10); + setLuaSideEffect(); + try { + dnsdist::configuration::updateImmutableConfiguration([capacity, numberOfShards](dnsdist::configuration::Configuration& config) { + config.d_ringsCapacity = capacity; + if (numberOfShards) { + config.d_ringsNumberOfShards = *numberOfShards; + } + }); } - else { - g_rings.setCapacity(0, 1); + catch (const std::exception& exp) { + g_outputBuffer = "setRingBuffersSize cannot be used at runtime!\n"; + errlog("setRingBuffersSize cannot be used at runtime!"); } }); - luaCtx.writeFunction("setRingBuffersLockRetries", [](uint64_t retries) { - setLuaSideEffect(); - g_rings.setNumberOfLockRetries(retries); - }); - - luaCtx.writeFunction("setRingBuffersOptions", [](const LuaAssociativeTable>& options) { - setLuaSideEffect(); - if (!checkConfigurationTime("setRingBuffersOptions")) { + luaCtx.writeFunction("setRingBuffersOptions", [client](const LuaAssociativeTable>& options) { + if (client) { return; } - if (options.count("lockRetries") > 0) { - auto retries = boost::get(options.at("lockRetries")); - g_rings.setNumberOfLockRetries(retries); - } - if (options.count("recordQueries") > 0) { - auto record = boost::get(options.at("recordQueries")); - g_rings.setRecordQueries(record); + setLuaSideEffect(); + try { + dnsdist::configuration::updateImmutableConfiguration([&options](dnsdist::configuration::Configuration& config) { + if (options.count("lockRetries") > 0) { + config.d_ringsNbLockTries = boost::get(options.at("lockRetries")); + } + if (options.count("recordQueries") > 0) { + config.d_ringsRecordQueries = boost::get(options.at("recordQueries")); + } + if (options.count("recordResponses") > 0) { + config.d_ringsRecordResponses = boost::get(options.at("recordResponses")); + } + }); } - if (options.count("recordResponses") > 0) { - auto record = boost::get(options.at("recordResponses")); - g_rings.setRecordResponses(record); + catch (const std::exception& exp) { + g_outputBuffer = "setRingBuffersOption cannot be used at runtime!\n"; + errlog("setRingBuffersOption cannot be used at runtime!"); } }); @@ -2291,9 +2299,6 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck) #endif /* DISABLE_POLICIES_BINDINGS */ luaCtx.writeFunction("setProxyProtocolACL", [](LuaTypeOrArrayOf inp) { - if (!checkConfigurationTime("setProxyProtocolACL")) { - return; - } setLuaSideEffect(); NetmaskGroup nmg; if (auto* str = boost::get(&inp)) { diff --git a/pdns/dnsdistdist/dnsdist-metrics.cc b/pdns/dnsdistdist/dnsdist-metrics.cc index 4c647db017..483d7b2939 100644 --- a/pdns/dnsdistdist/dnsdist-metrics.cc +++ b/pdns/dnsdistdist/dnsdist-metrics.cc @@ -146,7 +146,9 @@ Stats::Stats() : {"cpu-user-msec", getCPUTimeUser}, {"fd-usage", getOpenFileDescriptors}, {"dyn-blocked", &dynBlocked}, +#ifndef DISABLE_DYNBLOCKS {"dyn-block-nmg-size", [](const std::string&) { return dnsdist::DynamicBlocks::getClientAddressDynamicRules().size(); }}, +#endif /* DISABLE_DYNBLOCKS */ {"security-status", &securityStatus}, {"doh-query-pipe-full", &dohQueryPipeFull}, {"doh-response-pipe-full", &dohResponsePipeFull}, diff --git a/pdns/dnsdistdist/dnsdist-rings.cc b/pdns/dnsdistdist/dnsdist-rings.cc index ba55561fed..a25f84cf86 100644 --- a/pdns/dnsdistdist/dnsdist-rings.cc +++ b/pdns/dnsdistdist/dnsdist-rings.cc @@ -24,21 +24,17 @@ #include "dnsdist-rings.hh" -void Rings::setCapacity(size_t newCapacity, size_t numberOfShards) -{ - if (d_initialized) { - throw std::runtime_error("Rings::setCapacity() should not be called once the rings have been initialized"); - } - d_capacity = newCapacity; - d_numberOfShards = numberOfShards; -} - -void Rings::init() +void Rings::init(size_t capacity, size_t numberOfShards, size_t nbLockRetries, bool recordQueries, bool recordResponses) { if (d_initialized.exchange(true)) { throw std::runtime_error("Rings::init() should only be called once"); } + d_capacity = capacity; + d_numberOfShards = numberOfShards; + d_nbLockTries = nbLockRetries; + d_recordQueries = recordQueries; + d_recordResponses = recordResponses; if (d_numberOfShards <= 1) { d_nbLockTries = 0; } @@ -61,26 +57,6 @@ void Rings::init() d_nbResponseEntries = 0; } -void Rings::setNumberOfLockRetries(size_t retries) -{ - if (d_numberOfShards <= 1) { - d_nbLockTries = 0; - } - else { - d_nbLockTries = retries; - } -} - -void Rings::setRecordQueries(bool record) -{ - d_recordQueries = record; -} - -void Rings::setRecordResponses(bool record) -{ - d_recordResponses = record; -} - size_t Rings::numDistinctRequestors() { std::set requestors; diff --git a/pdns/dnsdistdist/dnsdist-rings.hh b/pdns/dnsdistdist/dnsdist-rings.hh index a98b72110f..91b90e3611 100644 --- a/pdns/dnsdistdist/dnsdist-rings.hh +++ b/pdns/dnsdistdist/dnsdist-rings.hh @@ -73,22 +73,11 @@ struct Rings LockGuarded> respRing; }; - Rings(size_t capacity = 10000, size_t numberOfShards = 10, size_t nbLockTries = 5, bool keepLockingStats = false) : - d_blockingQueryInserts(0), d_blockingResponseInserts(0), d_deferredQueryInserts(0), d_deferredResponseInserts(0), d_nbQueryEntries(0), d_nbResponseEntries(0), d_currentShardId(0), d_capacity(capacity), d_numberOfShards(numberOfShards), d_nbLockTries(nbLockTries), d_keepLockingStats(keepLockingStats) - { - } - std::unordered_map>> getTopBandwidth(unsigned int numentries); size_t numDistinctRequestors(); - /* this function should not be called after init() has been called */ - void setCapacity(size_t newCapacity, size_t numberOfShards); /* This function should only be called at configuration time before any query or response has been inserted */ - void init(); - - void setNumberOfLockRetries(size_t retries); - void setRecordQueries(bool); - void setRecordResponses(bool); + void init(size_t capacity, size_t numberOfShards, size_t nbLockRetries = 5, bool recordQueries = true, bool recordResponses = true); size_t getNumberOfShards() const { @@ -125,13 +114,13 @@ struct Rings #endif return; } - if (d_keepLockingStats) { + if (s_keepLockingStats) { ++d_deferredQueryInserts; } } /* out of luck, let's just wait */ - if (d_keepLockingStats) { + if (s_keepLockingStats) { ++d_blockingResponseInserts; } auto& shard = getOneShard(); @@ -152,13 +141,13 @@ struct Rings insertResponseLocked(*lock, when, requestor, name, qtype, usec, size, dh, backend, protocol); return; } - if (d_keepLockingStats) { + if (s_keepLockingStats) { ++d_deferredResponseInserts; } } /* out of luck, let's just wait */ - if (d_keepLockingStats) { + if (s_keepLockingStats) { ++d_blockingResponseInserts; } auto& shard = getOneShard(); @@ -204,10 +193,10 @@ struct Rings } std::vector> d_shards; - pdns::stat_t d_blockingQueryInserts; - pdns::stat_t d_blockingResponseInserts; - pdns::stat_t d_deferredQueryInserts; - pdns::stat_t d_deferredResponseInserts; + pdns::stat_t d_blockingQueryInserts{0}; + pdns::stat_t d_blockingResponseInserts{0}; + pdns::stat_t d_deferredQueryInserts{0}; + pdns::stat_t d_deferredResponseInserts{0}; private: size_t getShardId() @@ -248,15 +237,16 @@ private: ring.push_back({requestor, backend, name, when, dh, usec, size, qtype, protocol}); } - std::atomic d_nbQueryEntries; - std::atomic d_nbResponseEntries; - std::atomic d_currentShardId; + static constexpr bool s_keepLockingStats{false}; + + std::atomic d_nbQueryEntries{0}; + std::atomic d_nbResponseEntries{0}; + std::atomic d_currentShardId{0}; std::atomic d_initialized{false}; - size_t d_capacity; - size_t d_numberOfShards; - size_t d_nbLockTries = 5; - bool d_keepLockingStats{false}; + size_t d_capacity{10000}; + size_t d_numberOfShards{10}; + size_t d_nbLockTries{5}; bool d_recordQueries{true}; bool d_recordResponses{true}; }; diff --git a/pdns/dnsdistdist/dnsdist-web.hh b/pdns/dnsdistdist/dnsdist-web.hh index 1c76a194f8..9acff20f98 100644 --- a/pdns/dnsdistdist/dnsdist-web.hh +++ b/pdns/dnsdistdist/dnsdist-web.hh @@ -2,6 +2,7 @@ #include "credentials.hh" #include "dnsdist-prometheus.hh" +#include "sstuff.hh" namespace dnsdist::webserver { diff --git a/pdns/dnsdistdist/dnsdist.cc b/pdns/dnsdistdist/dnsdist.cc index b47a2d44e1..ecc54d586d 100644 --- a/pdns/dnsdistdist/dnsdist.cc +++ b/pdns/dnsdistdist/dnsdist.cc @@ -2793,7 +2793,7 @@ static void cleanupLuaObjects() config.d_pools.clear(); config.d_backends.clear(); }); - clearWebHandlers(); + dnsdist::webserver::clearWebHandlers(); dnsdist::lua::hooks::clearMaintenanceHooks(); } #endif /* defined(COVERAGE) || (defined(__SANITIZE_ADDRESS__) && defined(HAVE_LEAK_SANITIZER_INTERFACE)) */ @@ -2824,6 +2824,11 @@ static void sigTermHandler([[maybe_unused]] int sig) if (dnsdist::g_asyncHolder) { dnsdist::g_asyncHolder->stop(); } + + for (auto& backend : dnsdist::configuration::getCurrentRuntimeConfiguration().d_backends) { + backend->stop(); + } + { auto lock = g_lua.lock(); cleanupLuaObjects(); @@ -3413,7 +3418,10 @@ int main(int argc, char** argv) #endif /* HAVE_DNS_OVER_HTTPS && HAVE_NGHTTP2 */ } - g_rings.init(); + { + const auto& config = dnsdist::configuration::getImmutableConfiguration(); + g_rings.init(config.d_ringsCapacity, config.d_ringsNumberOfShards, config.d_ringsNbLockTries, config.d_ringsRecordQueries, config.d_ringsRecordResponses); + } for (auto& frontend : g_frontends) { setUpLocalBind(frontend); diff --git a/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc b/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc index 41fd39d46a..efd21e8d36 100644 --- a/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc +++ b/pdns/dnsdistdist/test-dnsdist-lua-ffi.cc @@ -750,7 +750,7 @@ BOOST_AUTO_TEST_CASE(test_RingBuffers) gettime(&now); g_rings.reset(); - g_rings.init(); + g_rings.init(10000, 10); BOOST_CHECK_EQUAL(g_rings.getNumberOfQueryEntries(), 0U); g_rings.insertQuery(now, requestor1, qname, qtype, size, dh, protocol); diff --git a/pdns/dnsdistdist/test-dnsdistdynblocks_hh.cc b/pdns/dnsdistdist/test-dnsdistdynblocks_hh.cc index f8d46b383a..0db9579a5b 100644 --- a/pdns/dnsdistdist/test-dnsdistdynblocks_hh.cc +++ b/pdns/dnsdistdist/test-dnsdistdynblocks_hh.cc @@ -24,7 +24,7 @@ struct TestFixture TestFixture() { g_rings.reset(); - g_rings.init(); + g_rings.init(10000, 10); } ~TestFixture() { @@ -428,8 +428,7 @@ BOOST_FIXTURE_TEST_CASE(test_DynBlockRulesGroup_QueryRate_responses, TestFixture /* 100k entries, one shard */ g_rings.reset(); - g_rings.setCapacity(1000000, 1); - g_rings.init(); + g_rings.init(1000000, 1); size_t numberOfSeconds = 10; size_t blockDuration = 60; @@ -1229,8 +1228,7 @@ BOOST_FIXTURE_TEST_CASE(test_DynBlockRulesMetricsCache_GetTopN, TestFixture) { g_rings.reset(); /* 10M entries, only one shard */ - g_rings.setCapacity(10000000, 1); - g_rings.init(); + g_rings.init(10000000, 1); { DynBlockRulesGroup dbrg; diff --git a/pdns/dnsdistdist/test-dnsdistrings_cc.cc b/pdns/dnsdistdist/test-dnsdistrings_cc.cc index 77450c8b05..ad81e1ec39 100644 --- a/pdns/dnsdistdist/test-dnsdistrings_cc.cc +++ b/pdns/dnsdistdist/test-dnsdistrings_cc.cc @@ -15,8 +15,8 @@ BOOST_AUTO_TEST_SUITE(dnsdistrings_cc) static void test_ring(size_t maxEntries, size_t numberOfShards, size_t nbLockTries) { - Rings rings(maxEntries, numberOfShards, nbLockTries); - rings.init(); + Rings rings; + rings.init(maxEntries, numberOfShards, nbLockTries); size_t entriesPerShard = maxEntries / numberOfShards; BOOST_CHECK_EQUAL(rings.getNumberOfShards(), numberOfShards); @@ -208,8 +208,8 @@ BOOST_AUTO_TEST_CASE(test_Rings_Threaded) { dnsdist::Protocol protocol = dnsdist::Protocol::DoUDP; dnsdist::Protocol outgoingProtocol = dnsdist::Protocol::DoUDP; - Rings rings(numberOfEntries, numberOfShards, lockAttempts, true); - rings.init(); + Rings rings; + rings.init(numberOfEntries, numberOfShards, lockAttempts, true); #if defined(DNSDIST_RINGS_WITH_MACADDRESS) Rings::Query query({requestor, qname, now, dh, size, qtype, protocol, dnsdist::MacAddress(), false}); #else