Merge branch 'develop' into Add_age_metric

Author: kuznetsss

.clang-format

@@ -22,7 +22,7 @@ BreakBeforeBinaryOperators: false
 BreakBeforeBraces: WebKit
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializersBeforeComma: true
-ColumnLimit: 120
+ColumnLimit: 100
 CommentPragmas: "^ IWYU pragma:"
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 4

benchmarks/rpc/WorkQueueBenchmarks.cpp

@@ -51,12 +51,15 @@ auto const kCONFIG = ClioConfigDefinition{
     {"log.channels.[].channel", Array{ConfigValue{ConfigType::String}}},
     {"log.channels.[].level", Array{ConfigValue{ConfigType::String}}},
     {"log.level", ConfigValue{ConfigType::String}.defaultValue("info")},
-    {"log.format", ConfigValue{ConfigType::String}.defaultValue(R"(%Y-%m-%d %H:%M:%S.%f %^%3!l:%n%$ - %v)")},
+    {"log.format",
+     ConfigValue{ConfigType::String}.defaultValue(R"(%Y-%m-%d %H:%M:%S.%f %^%3!l:%n%$ - %v)")},
     {"log.is_async", ConfigValue{ConfigType::Boolean}.defaultValue(false)},
     {"log.enable_console", ConfigValue{ConfigType::Boolean}.defaultValue(false)},
     {"log.directory", ConfigValue{ConfigType::String}.optional()},
-    {"log.rotation_size", ConfigValue{ConfigType::Integer}.defaultValue(2048).withConstraint(gValidateUint32)},
-    {"log.directory_max_files", ConfigValue{ConfigType::Integer}.defaultValue(25).withConstraint(gValidateUint32)},
+    {"log.rotation_size",
+     ConfigValue{ConfigType::Integer}.defaultValue(2048).withConstraint(gValidateUint32)},
+    {"log.directory_max_files",
+     ConfigValue{ConfigType::Integer}.defaultValue(25).withConstraint(gValidateUint32)},
     {"log.tag_style", ConfigValue{ConfigType::String}.defaultValue("none")},
 };
 
@@ -124,9 +127,14 @@ benchmarkWorkQueue(benchmark::State& state)
         ASSERT(totalQueued <= itemsPerClient * clientThreads, "Queued more than requested");
 
         if (maxQueueSize == 0) {
-            ASSERT(totalQueued == itemsPerClient * clientThreads, "Queued exactly the expected amount");
+            ASSERT(
+                totalQueued == itemsPerClient * clientThreads, "Queued exactly the expected amount"
+            );
         } else {
-            ASSERT(totalQueued >= std::min(maxQueueSize, itemsPerClient * clientThreads), "Queued less than expected");
+            ASSERT(
+                totalQueued >= std::min(maxQueueSize, itemsPerClient * clientThreads),
+                "Queued less than expected"
+            );
         }
     }
 }

benchmarks/util/log/LoggerBenchmark.cpp

@@ -62,8 +62,9 @@ uniqueLogDir()
 {
     auto const epochTime = std::chrono::high_resolution_clock::now().time_since_epoch();
     auto const tmpDir = std::filesystem::temp_directory_path();
-    std::string const dirName =
-        fmt::format("logs_{}", std::chrono::duration_cast<std::chrono::microseconds>(epochTime).count());
+    std::string const dirName = fmt::format(
+        "logs_{}", std::chrono::duration_cast<std::chrono::microseconds>(epochTime).count()
+    );
     return tmpDir / "clio_benchmark" / dirName;
 }
 
@@ -108,7 +109,8 @@ benchmarkConcurrentFileLogging(benchmark::State& state)
                     channel, fileSink, spdlog::thread_pool(), spdlog::async_overflow_policy::block
                 );
                 spdlog::register_logger(logger);
-                Logger const threadLogger = BenchmarkLoggingInitializer::getLogger(std::move(logger));
+                Logger const threadLogger =
+                    BenchmarkLoggingInitializer::getLogger(std::move(logger));
 
                 barrier.arrive_and_wait();
 
@@ -124,13 +126,16 @@ benchmarkConcurrentFileLogging(benchmark::State& state)
         spdlog::shutdown();
 
         auto const end = std::chrono::high_resolution_clock::now();
-        state.SetIterationTime(std::chrono::duration_cast<std::chrono::duration<double>>(end - start).count());
+        state.SetIterationTime(
+            std::chrono::duration_cast<std::chrono::duration<double>>(end - start).count()
+        );
 
         std::filesystem::remove_all(logDir);
     }
 
     auto const totalMessages = numThreads * messagesPerThread;
-    state.counters["TotalMessagesRate"] = benchmark::Counter(totalMessages, benchmark::Counter::kIsRate);
+    state.counters["TotalMessagesRate"] =
+        benchmark::Counter(totalMessages, benchmark::Counter::kIsRate);
     state.counters["Threads"] = numThreads;
     state.counters["MessagesPerThread"] = messagesPerThread;
 }

src/app/CliArgs.cpp

@@ -58,12 +58,16 @@ CliArgs::parse(int argc, char const* argv[])
     positional.add("conf", 1);
 
     auto const printHelp = [&description]() {
-        std::cout << "Clio server " << util::build::getClioFullVersionString() << "\n\n" << description;
+        std::cout << "Clio server " << util::build::getClioFullVersionString() << "\n\n"
+                  << description;
     };
 
     po::variables_map parsed;
     try {
-        po::store(po::command_line_parser(argc, argv).options(description).positional(positional).run(), parsed);
+        po::store(
+            po::command_line_parser(argc, argv).options(description).positional(positional).run(),
+            parsed
+        );
         po::notify(parsed);
     } catch (po::error const& e) {
         std::cerr << "Error: " << e.what() << std::endl << std::endl;
@@ -87,7 +91,8 @@ CliArgs::parse(int argc, char const* argv[])
     if (parsed.contains("config-description")) {
         std::filesystem::path const filePath = parsed["config-description"].as<std::string>();
 
-        auto const res = util::config::ClioConfigDescription::generateConfigDescriptionToFile(filePath);
+        auto const res =
+            util::config::ClioConfigDescription::generateConfigDescriptionToFile(filePath);
         if (res.has_value())
             return Action{Action::Exit{EXIT_SUCCESS}};
 
@@ -100,14 +105,20 @@ CliArgs::parse(int argc, char const* argv[])
     if (parsed.contains("migrate")) {
         auto const opt = parsed["migrate"].as<std::string>();
         if (opt == "status")
-            return Action{Action::Migrate{.configPath = std::move(configPath), .subCmd = MigrateSubCmd::status()}};
-        return Action{Action::Migrate{.configPath = std::move(configPath), .subCmd = MigrateSubCmd::migration(opt)}};
+            return Action{Action::Migrate{
+                .configPath = std::move(configPath), .subCmd = MigrateSubCmd::status()
+            }};
+        return Action{Action::Migrate{
+            .configPath = std::move(configPath), .subCmd = MigrateSubCmd::migration(opt)
+        }};
     }
 
     if (parsed.contains("verify"))
         return Action{Action::VerifyConfig{.configPath = std::move(configPath)}};
 
-    return Action{Action::Run{.configPath = std::move(configPath), .useNgWebServer = parsed.contains("ng-web-server")}};
+    return Action{Action::Run{
+        .configPath = std::move(configPath), .useNgWebServer = parsed.contains("ng-web-server")
+    }};
 }
 
 }  // namespace app

src/app/CliArgs.hpp

@@ -79,7 +79,8 @@ class CliArgs {
         /**
          * @brief Apply a function to the action.
          *
-         * @tparam Processors Action processors types. Must be callable with the action type and return int.
+         * @tparam Processors Action processors types. Must be callable with the action type and
+         * return int.
          * @param processors Action processors.
          * @return Exit code.
          */

src/app/ClioApplication.cpp

@@ -136,14 +136,15 @@ ClioApplication::run(bool const useNgWebServer)
         auto const migrationInspector = migration::makeMigrationInspector(config_, backend);
         // Check if any migration is blocking Clio server starting.
         if (migrationInspector->isBlockingClio() and backend->hardFetchLedgerRangeNoThrow()) {
-            LOG(util::LogService::error())
-                << "Existing Migration is blocking Clio, Please complete the database migration first.";
+            LOG(util::LogService::error()) << "Existing Migration is blocking Clio, Please "
+                                              "complete the database migration first.";
             return EXIT_FAILURE;
         }
     }
 
     // Manages clients subscribed to streams
-    auto subscriptions = feed::SubscriptionManager::makeSubscriptionManager(config_, backend, amendmentCenter);
+    auto subscriptions =
+        feed::SubscriptionManager::makeSubscriptionManager(config_, backend, amendmentCenter);
 
     // Tracks which ledgers have been validated by the network
     auto ledgers = etl::NetworkValidatedLedgers::makeValidatedLedgers();
@@ -156,7 +157,8 @@ ClioApplication::run(bool const useNgWebServer)
         config_, ioc, backend, subscriptions, std::make_unique<util::MTRandomGenerator>(), ledgers
     );
 
-    // ETL is responsible for writing and publishing to streams. In read-only mode, ETL only publishes
+    // ETL is responsible for writing and publishing to streams. In read-only mode, ETL only
+    // publishes
     auto etl = etl::ETLService::makeETLService(
         config_, std::move(systemState), ctx, backend, subscriptions, balancer, ledgers
     );
@@ -169,15 +171,19 @@ ClioApplication::run(bool const useNgWebServer)
     );
 
     using RPCEngineType = rpc::RPCEngine<rpc::Counters>;
-    auto const rpcEngine =
-        RPCEngineType::makeRPCEngine(config_, backend, balancer, dosGuard, workQueue, counters, handlerProvider);
+    auto const rpcEngine = RPCEngineType::makeRPCEngine(
+        config_, backend, balancer, dosGuard, workQueue, counters, handlerProvider
+    );
 
     if (useNgWebServer or config_.get<bool>("server.__ng_web_server")) {
-        web::ng::RPCServerHandler<RPCEngineType> handler{config_, backend, rpcEngine, etl, dosGuard};
+        web::ng::RPCServerHandler<RPCEngineType> handler{
+            config_, backend, rpcEngine, etl, dosGuard
+        };
 
         auto expectedAdminVerifier = web::makeAdminVerificationStrategy(config_);
         if (not expectedAdminVerifier.has_value()) {
-            LOG(util::LogService::error()) << "Error creating admin verifier: " << expectedAdminVerifier.error();
+            LOG(util::LogService::error())
+                << "Error creating admin verifier: " << expectedAdminVerifier.error();
             return EXIT_FAILURE;
         }
         auto const adminVerifier = std::move(expectedAdminVerifier).value();
@@ -226,12 +232,21 @@ ClioApplication::run(bool const useNgWebServer)
     }
 
     // Init the web server
-    auto handler = std::make_shared<web::RPCServerHandler<RPCEngineType>>(config_, backend, rpcEngine, etl, dosGuard);
+    auto handler = std::make_shared<web::RPCServerHandler<RPCEngineType>>(
+        config_, backend, rpcEngine, etl, dosGuard
+    );
 
     auto const httpServer = web::makeHttpServer(config_, ioc, dosGuard, handler, cache);
     appStopper_.setOnStop(
         Stopper::makeOnStopCallback(
-            *httpServer, *balancer, *etl, *subscriptions, *backend, cacheSaver, clusterCommunicationService, ioc
+            *httpServer,
+            *balancer,
+            *etl,
+            *subscriptions,
+            *backend,
+            cacheSaver,
+            clusterCommunicationService,
+            ioc
         )
     );
 

src/app/Stopper.hpp

@@ -39,7 +39,8 @@
 namespace app {
 
 /**
- * @brief Application stopper class. On stop it will create a new thread to run all the shutdown tasks.
+ * @brief Application stopper class. On stop it will create a new thread to run all the shutdown
+ * tasks.
  */
 class Stopper {
     boost::asio::io_context ctx_;

src/app/VerifyConfig.hpp

@@ -41,7 +41,8 @@ parseConfig(std::string_view configPath)
 
     auto const json = ConfigFileJson::makeConfigFileJson(configPath);
     if (!json.has_value()) {
-        std::cerr << "Error parsing json from config: " << configPath << "\n" << json.error().error << std::endl;
+        std::cerr << "Error parsing json from config: " << configPath << "\n"
+                  << json.error().error << std::endl;
         return false;
     }
     auto const errors = getClioConfig().parse(json.value());

src/app/WebHandlers.cpp

@@ -51,9 +51,9 @@ OnConnectCheck::operator()(web::ng::Connection const& connection)
 {
     dosguard_.get().increment(connection.ip());
     if (not dosguard_.get().isOk(connection.ip())) {
-        return std::unexpected{
-            web::ng::Response{boost::beast::http::status::too_many_requests, "Too many requests", connection}
-        };
+        return std::unexpected{web::ng::Response{
+            boost::beast::http::status::too_many_requests, "Too many requests", connection
+        }};
     }
 
     return {};
@@ -80,7 +80,10 @@ DisconnectHook::operator()(web::ng::Connection const& connection)
     dosguard_.get().decrement(connection.ip());
 }
 
-MetricsHandler::MetricsHandler(std::shared_ptr<web::AdminVerificationStrategy> adminVerifier, rpc::WorkQueue& workQueue)
+MetricsHandler::MetricsHandler(
+    std::shared_ptr<web::AdminVerificationStrategy> adminVerifier,
+    rpc::WorkQueue& workQueue
+)
     : adminVerifier_{std::move(adminVerifier)}, workQueue_{std::ref(workQueue)}
 {
 }
@@ -120,7 +123,9 @@ MetricsHandler::operator()(
 
     if (!postSuccessful) {
         return web::ng::Response{
-            boost::beast::http::status::too_many_requests, rpc::makeError(rpc::RippledError::rpcTOO_BUSY), request
+            boost::beast::http::status::too_many_requests,
+            rpc::makeError(rpc::RippledError::rpcTOO_BUSY),
+            request
         };
     }
 
@@ -177,7 +182,9 @@ CacheStateHandler::operator()(
     if (cache_.get().isFull())
         return web::ng::Response{boost::beast::http::status::ok, kCACHE_CHECK_LOADED_HTML, request};
 
-    return web::ng::Response{boost::beast::http::status::service_unavailable, kCACHE_CHECK_NOT_LOADED_HTML, request};
+    return web::ng::Response{
+        boost::beast::http::status::service_unavailable, kCACHE_CHECK_NOT_LOADED_HTML, request
+    };
 }
 
 }  // namespace app

src/app/WebHandlers.hpp

@@ -68,8 +68,8 @@ class OnConnectCheck {
 };
 
 /**
- * @brief A function object that is called when the IP of a connection changes (usually if proxy detected).
- * This is used to update the DOS guard.
+ * @brief A function object that is called when the IP of a connection changes (usually if proxy
+ * detected). This is used to update the DOS guard.
  */
 class IpChangeHook {
     std::reference_wrapper<web::dosguard::DOSGuardInterface> dosguard_;
@@ -126,10 +126,14 @@ class MetricsHandler {
     /**
      * @brief Construct a new MetricsHandler object
      *
-     * @param adminVerifier The AdminVerificationStrategy to use for verifying the connection for admin access.
+     * @param adminVerifier The AdminVerificationStrategy to use for verifying the connection for
+     * admin access.
      * @param workQueue The WorkQueue to use for handling the request.
      */
-    MetricsHandler(std::shared_ptr<web::AdminVerificationStrategy> adminVerifier, rpc::WorkQueue& workQueue);
+    MetricsHandler(
+        std::shared_ptr<web::AdminVerificationStrategy> adminVerifier,
+        rpc::WorkQueue& workQueue
+    );
 
     /**
      * @brief The call of the function object.
@@ -214,10 +218,14 @@ class RequestHandler {
     /**
      * @brief Construct a new RequestHandler object
      *
-     * @param adminVerifier The AdminVerificationStrategy to use for verifying the connection for admin access.
+     * @param adminVerifier The AdminVerificationStrategy to use for verifying the connection for
+     * admin access.
      * @param rpcHandler The RPC handler to use for handling the request.
      */
-    RequestHandler(std::shared_ptr<web::AdminVerificationStrategy> adminVerifier, RpcHandlerType& rpcHandler)
+    RequestHandler(
+        std::shared_ptr<web::AdminVerificationStrategy> adminVerifier,
+        RpcHandlerType& rpcHandler
+    )
         : adminVerifier_(std::move(adminVerifier)), rpcHandler_(rpcHandler)
     {
     }