refactor: Replace all old instances of Config with New Config (#1627)

Fixes #1184 
Previous PR's found [here](#1593) and
[here](#1544)

src/app/ClioApplication.cpp

@@ -31,8 +31,8 @@
 #include "rpc/WorkQueue.hpp"
 #include "rpc/common/impl/HandlerProvider.hpp"
 #include "util/build/Build.hpp"
-#include "util/config/Config.hpp"
 #include "util/log/Logger.hpp"
+#include "util/newconfig/ConfigDefinition.hpp"
 #include "util/prometheus/Prometheus.hpp"
 #include "web/AdminVerificationStrategy.hpp"
 #include "web/RPCServerHandler.hpp"
@@ -78,7 +78,8 @@ start(boost::asio::io_context& ioc, std::uint32_t numThreads)
 
 }  // namespace
 
-ClioApplication::ClioApplication(util::Config const& config) : config_(config), signalsHandler_{config_}
+ClioApplication::ClioApplication(util::config::ClioConfigDefinition const& config)
+    : config_(config), signalsHandler_{config_}
 {
     LOG(util::LogService::info()) << "Clio version: " << util::build::getClioFullVersionString();
     PrometheusService::init(config);
@@ -87,11 +88,7 @@ ClioApplication::ClioApplication(util::Config const& config) : config_(config),
 int
 ClioApplication::run(bool const useNgWebServer)
 {
-    auto const threads = config_.valueOr("io_threads", 2);
-    if (threads <= 0) {
-        LOG(util::LogService::fatal()) << "io_threads is less than 1";
-        return EXIT_FAILURE;
-    }
+    auto const threads = config_.get<uint16_t>("io_threads");
     LOG(util::LogService::info()) << "Number of io threads = " << threads;
 
     // IO context to handle all incoming requests, as well as other things.
@@ -132,7 +129,7 @@ ClioApplication::run(bool const useNgWebServer)
     auto const rpcEngine =
         RPCEngineType::make_RPCEngine(config_, backend, balancer, dosGuard, workQueue, counters, handlerProvider);
 
-    if (useNgWebServer or config_.valueOr("server.__ng_web_server", false)) {
+    if (useNgWebServer or config_.get<bool>("server.__ng_web_server")) {
         web::ng::RPCServerHandler<RPCEngineType, etl::ETLService> handler{config_, backend, rpcEngine, etl};
 
         auto expectedAdminVerifier = web::make_AdminVerificationStrategy(config_);

src/app/ClioApplication.hpp

@@ -18,17 +18,16 @@
 //==============================================================================
 
 #pragma once
-
 #include "util/SignalsHandler.hpp"
-#include "util/config//Config.hpp"
+#include "util/newconfig/ConfigDefinition.hpp"
 
 namespace app {
 
 /**
  * @brief The main application class
  */
 class ClioApplication {
-    util::Config const& config_;
+    util::config::ClioConfigDefinition const& config_;
     util::SignalsHandler signalsHandler_;
 
 public:
@@ -37,7 +36,7 @@ class ClioApplication {
      *
      * @param config The configuration of the application
      */
-    ClioApplication(util::Config const& config);
+    ClioApplication(util::config::ClioConfigDefinition const& config);
 
     /**
      * @brief Run the application

src/data/BackendFactory.hpp

@@ -22,8 +22,8 @@
 #include "data/BackendInterface.hpp"
 #include "data/CassandraBackend.hpp"
 #include "data/cassandra/SettingsProvider.hpp"
-#include "util/config/Config.hpp"
 #include "util/log/Logger.hpp"
+#include "util/newconfig/ConfigDefinition.hpp"
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/predicate.hpp>
@@ -41,18 +41,18 @@ namespace data {
  * @return A shared_ptr<BackendInterface> with the selected implementation
  */
 inline std::shared_ptr<BackendInterface>
-make_Backend(util::Config const& config)
+make_Backend(util::config::ClioConfigDefinition const& config)
 {
     static util::Logger const log{"Backend"};
     LOG(log.info()) << "Constructing BackendInterface";
 
-    auto const readOnly = config.valueOr("read_only", false);
+    auto const readOnly = config.get<bool>("read_only");
 
-    auto const type = config.value<std::string>("database.type");
+    auto const type = config.get<std::string>("database.type");
     std::shared_ptr<BackendInterface> backend = nullptr;
 
     if (boost::iequals(type, "cassandra")) {
-        auto cfg = config.section("database." + type);
+        auto const cfg = config.getObject("database." + type);
         backend = std::make_shared<data::cassandra::CassandraBackend>(data::cassandra::SettingsProvider{cfg}, readOnly);
     }
 

src/data/CassandraBackend.hpp

@@ -93,7 +93,7 @@ class BasicCassandraBackend : public BackendInterface {
         , executor_{settingsProvider_.getSettings(), handle_}
     {
         if (auto const res = handle_.connect(); not res)
-            throw std::runtime_error("Could not connect to databse: " + res.error());
+            throw std::runtime_error("Could not connect to database: " + res.error());
 
         if (not readOnly) {
             if (auto const res = handle_.execute(schema_.createKeyspace); not res) {

src/data/cassandra/SettingsProvider.cpp

@@ -22,7 +22,7 @@
 #include "data/cassandra/Types.hpp"
 #include "data/cassandra/impl/Cluster.hpp"
 #include "util/Constants.hpp"
-#include "util/config/Config.hpp"
+#include "util/newconfig/ObjectView.hpp"
 
 #include <boost/json/conversion.hpp>
 #include <boost/json/value.hpp>
@@ -36,43 +36,17 @@
 #include <ios>
 #include <iterator>
 #include <optional>
-#include <stdexcept>
 #include <string>
+#include <string_view>
 #include <system_error>
 
 namespace data::cassandra {
 
-namespace impl {
-inline static Settings::ContactPoints
-tag_invoke(boost::json::value_to_tag<Settings::ContactPoints>, boost::json::value const& value)
-{
-    if (not value.is_object()) {
-        throw std::runtime_error("Feed entire Cassandra section to parse Settings::ContactPoints instead");
-    }
-
-    util::Config const obj{value};
-    Settings::ContactPoints out;
-
-    out.contactPoints = obj.valueOrThrow<std::string>("contact_points", "`contact_points` must be a string");
-    out.port = obj.maybeValue<uint16_t>("port");
-
-    return out;
-}
-
-inline static Settings::SecureConnectionBundle
-tag_invoke(boost::json::value_to_tag<Settings::SecureConnectionBundle>, boost::json::value const& value)
-{
-    if (not value.is_string())
-        throw std::runtime_error("`secure_connect_bundle` must be a string");
-    return Settings::SecureConnectionBundle{value.as_string().data()};
-}
-}  // namespace impl
-
-SettingsProvider::SettingsProvider(util::Config const& cfg)
+SettingsProvider::SettingsProvider(util::config::ObjectView const& cfg)
     : config_{cfg}
-    , keyspace_{cfg.valueOr<std::string>("keyspace", "clio")}
+    , keyspace_{cfg.get<std::string>("keyspace")}
     , tablePrefix_{cfg.maybeValue<std::string>("table_prefix")}
-    , replicationFactor_{cfg.valueOr<uint16_t>("replication_factor", 3)}
+    , replicationFactor_{cfg.get<uint16_t>("replication_factor")}
     , settings_{parseSettings()}
 {
 }
@@ -86,8 +60,8 @@ SettingsProvider::getSettings() const
 std::optional<std::string>
 SettingsProvider::parseOptionalCertificate() const
 {
-    if (auto const certPath = config_.maybeValue<std::string>("certfile"); certPath) {
-        auto const path = std::filesystem::path(*certPath);
+    if (auto const certPath = config_.getValueView("certfile"); certPath.hasValue()) {
+        auto const path = std::filesystem::path(certPath.asString());
         std::ifstream fileStream(path.string(), std::ios::in);
         if (!fileStream) {
             throw std::system_error(errno, std::generic_category(), "Opening certificate " + path.string());
@@ -108,30 +82,34 @@ Settings
 SettingsProvider::parseSettings() const
 {
     auto settings = Settings::defaultSettings();
-    if (auto const bundle = config_.maybeValue<Settings::SecureConnectionBundle>("secure_connect_bundle"); bundle) {
-        settings.connectionInfo = *bundle;
+
+    // all config values used in settings is under "database.cassandra" prefix
+    if (config_.getValueView("secure_connect_bundle").hasValue()) {
+        auto const bundle = Settings::SecureConnectionBundle{(config_.get<std::string>("secure_connect_bundle"))};
+        settings.connectionInfo = bundle;
     } else {
-        settings.connectionInfo =
-            config_.valueOrThrow<Settings::ContactPoints>("Missing contact_points in Cassandra config");
+        Settings::ContactPoints out;
+        out.contactPoints = config_.get<std::string>("contact_points");
+        out.port = config_.maybeValue<uint32_t>("port");
+        settings.connectionInfo = out;
     }
 
-    settings.threads = config_.valueOr<uint32_t>("threads", settings.threads);
-    settings.maxWriteRequestsOutstanding =
-        config_.valueOr<uint32_t>("max_write_requests_outstanding", settings.maxWriteRequestsOutstanding);
-    settings.maxReadRequestsOutstanding =
-        config_.valueOr<uint32_t>("max_read_requests_outstanding", settings.maxReadRequestsOutstanding);
-    settings.coreConnectionsPerHost =
-        config_.valueOr<uint32_t>("core_connections_per_host", settings.coreConnectionsPerHost);
+    settings.threads = config_.get<uint32_t>("threads");
+    settings.maxWriteRequestsOutstanding = config_.get<uint32_t>("max_write_requests_outstanding");
+    settings.maxReadRequestsOutstanding = config_.get<uint32_t>("max_read_requests_outstanding");
+    settings.coreConnectionsPerHost = config_.get<uint32_t>("core_connections_per_host");
     settings.queueSizeIO = config_.maybeValue<uint32_t>("queue_size_io");
-    settings.writeBatchSize = config_.valueOr<std::size_t>("write_batch_size", settings.writeBatchSize);
+    settings.writeBatchSize = config_.get<std::size_t>("write_batch_size");
 
-    auto const connectTimeoutSecond = config_.maybeValue<uint32_t>("connect_timeout");
-    if (connectTimeoutSecond)
-        settings.connectionTimeout = std::chrono::milliseconds{*connectTimeoutSecond * util::MILLISECONDS_PER_SECOND};
+    if (config_.getValueView("connect_timeout").hasValue()) {
+        auto const connectTimeoutSecond = config_.get<uint32_t>("connect_timeout");
+        settings.connectionTimeout = std::chrono::milliseconds{connectTimeoutSecond * util::MILLISECONDS_PER_SECOND};
+    }
 
-    auto const requestTimeoutSecond = config_.maybeValue<uint32_t>("request_timeout");
-    if (requestTimeoutSecond)
-        settings.requestTimeout = std::chrono::milliseconds{*requestTimeoutSecond * util::MILLISECONDS_PER_SECOND};
+    if (config_.getValueView("request_timeout").hasValue()) {
+        auto const requestTimeoutSecond = config_.get<uint32_t>("request_timeout");
+        settings.requestTimeout = std::chrono::milliseconds{requestTimeoutSecond * util::MILLISECONDS_PER_SECOND};
+    }
 
     settings.certificate = parseOptionalCertificate();
     settings.username = config_.maybeValue<std::string>("username");

src/data/cassandra/SettingsProvider.hpp

@@ -19,10 +19,9 @@
 
 #pragma once
 
-#include "data/cassandra/Handle.hpp"
 #include "data/cassandra/Types.hpp"
-#include "util/config/Config.hpp"
-#include "util/log/Logger.hpp"
+#include "data/cassandra/impl/Cluster.hpp"
+#include "util/newconfig/ObjectView.hpp"
 
 #include <cstdint>
 #include <optional>
@@ -34,7 +33,7 @@ namespace data::cassandra {
  * @brief Provides settings for @ref BasicCassandraBackend.
  */
 class SettingsProvider {
-    util::Config config_;
+    util::config::ObjectView config_;
 
     std::string keyspace_;
     std::optional<std::string> tablePrefix_;
@@ -47,7 +46,7 @@ class SettingsProvider {
      *
      * @param cfg The config of Clio to use
      */
-    explicit SettingsProvider(util::Config const& cfg);
+    explicit SettingsProvider(util::config::ObjectView const& cfg);
 
     /**
      * @return The cluster settings

src/etl/CacheLoader.hpp

@@ -64,7 +64,11 @@ class CacheLoader {
      * @param backend The backend to use
      * @param cache The cache to load into
      */
-    CacheLoader(util::Config const& config, std::shared_ptr<BackendInterface> const& backend, CacheType& cache)
+    CacheLoader(
+        util::config::ClioConfigDefinition const& config,
+        std::shared_ptr<BackendInterface> const& backend,
+        CacheType& cache
+    )
         : backend_{backend}, cache_{cache}, settings_{make_CacheLoaderSettings(config)}, ctx_{settings_.numThreads}
     {
     }

src/etl/CacheLoaderSettings.cpp

@@ -19,11 +19,12 @@
 
 #include "etl/CacheLoaderSettings.hpp"
 
-#include "util/config/Config.hpp"
+#include "util/newconfig/ConfigDefinition.hpp"
 
 #include <boost/algorithm/string/predicate.hpp>
 
 #include <cstddef>
+#include <cstdint>
 #include <string>
 
 namespace etl {
@@ -47,31 +48,29 @@ CacheLoaderSettings::isDisabled() const
 }
 
 [[nodiscard]] CacheLoaderSettings
-make_CacheLoaderSettings(util::Config const& config)
+make_CacheLoaderSettings(util::config::ClioConfigDefinition const& config)
 {
     CacheLoaderSettings settings;
-    settings.numThreads = config.valueOr("io_threads", settings.numThreads);
-    if (config.contains("cache")) {
-        auto const cache = config.section("cache");
-        // Given diff number to generate cursors
-        settings.numCacheDiffs = cache.valueOr<size_t>("num_diffs", settings.numCacheDiffs);
-        // Given cursors number fetching from diff
-        settings.numCacheCursorsFromDiff = cache.valueOr<size_t>("num_cursors_from_diff", 0);
-        // Given cursors number fetching from account
-        settings.numCacheCursorsFromAccount = cache.valueOr<size_t>("num_cursors_from_account", 0);
+    settings.numThreads = config.get<uint16_t>("io_threads");
+    auto const cache = config.getObject("cache");
+    // Given diff number to generate cursors
+    settings.numCacheDiffs = cache.get<std::size_t>("num_diffs");
+    // Given cursors number fetching from diff
+    settings.numCacheCursorsFromDiff = cache.get<std::size_t>("num_cursors_from_diff");
+    // Given cursors number fetching from account
+    settings.numCacheCursorsFromAccount = cache.get<std::size_t>("num_cursors_from_account");
 
-        settings.numCacheMarkers = cache.valueOr<size_t>("num_markers", settings.numCacheMarkers);
-        settings.cachePageFetchSize = cache.valueOr<size_t>("page_fetch_size", settings.cachePageFetchSize);
+    settings.numCacheMarkers = cache.get<std::size_t>("num_markers");
+    settings.cachePageFetchSize = cache.get<std::size_t>("page_fetch_size");
+
+    auto const entry = cache.get<std::string>("load");
+    if (boost::iequals(entry, "sync"))
+        settings.loadStyle = CacheLoaderSettings::LoadStyle::SYNC;
+    if (boost::iequals(entry, "async"))
+        settings.loadStyle = CacheLoaderSettings::LoadStyle::ASYNC;
+    if (boost::iequals(entry, "none") or boost::iequals(entry, "no"))
+        settings.loadStyle = CacheLoaderSettings::LoadStyle::NONE;
 
-        if (auto entry = cache.maybeValue<std::string>("load"); entry) {
-            if (boost::iequals(*entry, "sync"))
-                settings.loadStyle = CacheLoaderSettings::LoadStyle::SYNC;
-            if (boost::iequals(*entry, "async"))
-                settings.loadStyle = CacheLoaderSettings::LoadStyle::ASYNC;
-            if (boost::iequals(*entry, "none") or boost::iequals(*entry, "no"))
-                settings.loadStyle = CacheLoaderSettings::LoadStyle::NONE;
-        }
-    }
     return settings;
 }