Merge branch 'develop' into release/2.6.0

Author: godexsoft

.github/workflows/release.yml

@@ -51,9 +51,9 @@ jobs:
     with:
       overwrite_release: false
       prerelease: ${{ contains(github.ref_name, '-') }}
-      title: "${{ github.ref_name}}"
+      title: "${{ github.ref_name }}"
       version: "${{ github.ref_name }}"
       header: >
         ${{ contains(github.ref_name, '-') && '> **Note:** Please remember that this is a release candidate and it is not recommended for production use.' || '' }}
       generate_changelog: ${{ !contains(github.ref_name, '-') }}
-      draft: true
+      draft: ${{ !contains(github.ref_name, '-') }}

src/data/BackendFactory.hpp

@@ -46,6 +46,7 @@ namespace data {
 inline std::shared_ptr<BackendInterface>
 makeBackend(util::config::ClioConfigDefinition const& config, data::LedgerCacheInterface& cache)
 {
+    using namespace cassandra::impl;
     static util::Logger const log{"Backend"};  // NOLINT(readability-identifier-naming)
     LOG(log.info()) << "Constructing BackendInterface";
 
@@ -56,7 +57,7 @@ makeBackend(util::config::ClioConfigDefinition const& config, data::LedgerCacheI
 
     if (boost::iequals(type, "cassandra")) {
         auto const cfg = config.getObject("database." + type);
-        if (cfg.getValueView("provider").asString() == toString(cassandra::impl::Provider::Keyspace)) {
+        if (providerFromString(cfg.getValueView("provider").asString()) == Provider::Keyspace) {
             backend = std::make_shared<data::cassandra::KeyspaceBackend>(
                 data::cassandra::SettingsProvider{cfg}, cache, readOnly
             );

src/data/CassandraBackend.hpp

@@ -189,10 +189,11 @@ class BasicCassandraBackend : public CassandraBackendFamily<
         auto const nftUris = executor_.readEach(yield, selectNFTURIStatements);
 
         for (auto i = 0u; i < nftIDs.size(); i++) {
-            if (auto const maybeRow = nftInfos[i].template get<uint32_t, ripple::AccountID, bool>(); maybeRow) {
+            if (auto const maybeRow = nftInfos[i].template get<uint32_t, ripple::AccountID, bool>();
+                maybeRow.has_value()) {
                 auto [seq, owner, isBurned] = *maybeRow;
                 NFT nft(nftIDs[i], seq, owner, isBurned);
-                if (auto const maybeUri = nftUris[i].template get<ripple::Blob>(); maybeUri)
+                if (auto const maybeUri = nftUris[i].template get<ripple::Blob>(); maybeUri.has_value())
                     nft.uri = *maybeUri;
                 ret.nfts.push_back(nft);
             }

src/data/KeyspaceBackend.hpp

@@ -57,9 +57,9 @@ namespace data::cassandra {
 /**
  * @brief Implements @ref CassandraBackendFamily for Keyspace
  *
- * @tparam SettingsProviderType The settings provider type to use
- * @tparam ExecutionStrategyType The execution strategy type to use
- * @tparam FetchLedgerCacheType The ledger header cache type to use
+ * @tparam SettingsProviderType The settings provider type
+ * @tparam ExecutionStrategyType The execution strategy type
+ * @tparam FetchLedgerCacheType The ledger header cache type
  */
 template <
     SomeSettingsProvider SettingsProviderType,
@@ -101,9 +101,9 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
         // !range_.has_value() means the table 'ledger_range' is not populated;
         // This would be the first write to the table.
         // In this case, insert both min_sequence/max_sequence range into the table.
-        if (not(range_.has_value())) {
-            executor_.writeSync(schema_->insertLedgerRange, false, ledgerSequence_);
-            executor_.writeSync(schema_->insertLedgerRange, true, ledgerSequence_);
+        if (not range_.has_value()) {
+            executor_.writeSync(schema_->insertLedgerRange, /* isLatestLedger =*/false, ledgerSequence_);
+            executor_.writeSync(schema_->insertLedgerRange, /* isLatestLedger =*/true, ledgerSequence_);
         }
 
         if (not this->executeSyncUpdate(schema_->updateLedgerRange.bind(ledgerSequence_, true, ledgerSequence_ - 1))) {
@@ -130,7 +130,7 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
             // Keyspace and ScyllaDB uses the same logic for taxon-filtered queries
             nftIDs = fetchNFTIDsByTaxon(issuer, *taxon, limit, cursorIn, yield);
         } else {
-            // --- Amazon Keyspaces Workflow for non-taxon queries ---
+            // Amazon Keyspaces Workflow for non-taxon queries
             auto const startTaxon = cursorIn.has_value() ? ripple::nft::toUInt32(ripple::nft::getTaxon(*cursorIn)) : 0;
             auto const startTokenID = cursorIn.value_or(ripple::uint256(0));
 
@@ -140,8 +140,8 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
             firstQuery.bindAt(3, Limit{limit});
 
             auto const firstRes = executor_.read(yield, firstQuery);
-            if (firstRes) {
-                for (auto const [nftID] : extract<ripple::uint256>(firstRes.value()))
+            if (firstRes.has_value()) {
+                for (auto const [nftID] : extract<ripple::uint256>(*firstRes))
                     nftIDs.push_back(nftID);
             }
 
@@ -152,8 +152,8 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
                 secondQuery.bindAt(2, Limit{remainingLimit});
 
                 auto const secondRes = executor_.read(yield, secondQuery);
-                if (secondRes) {
-                    for (auto const [nftID] : extract<ripple::uint256>(secondRes.value()))
+                if (secondRes.has_value()) {
+                    for (auto const [nftID] : extract<ripple::uint256>(*secondRes))
                         nftIDs.push_back(nftID);
                 }
             }
@@ -163,7 +163,7 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
 
     /**
      * @brief (Unsupported in Keyspaces) Fetches account root object indexes by page.
-     * * @note Loading the cache by enumerating all accounts is currently unsupported by the AWS Keyspaces backend.
+     * @note Loading the cache by enumerating all accounts is currently unsupported by the AWS Keyspaces backend.
      * This function's logic relies on "PER PARTITION LIMIT 1", which Keyspaces does not support, and there is
      * no efficient alternative. This is acceptable as the cache is primarily loaded via diffs. Calling this
      * function will throw an exception.
@@ -203,8 +203,8 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
         statement.bindAt(3, Limit{limit});
 
         auto const res = executor_.read(yield, statement);
-        if (res && res.value().hasRows()) {
-            for (auto const [nftID] : extract<ripple::uint256>(res.value()))
+        if (res.has_value() && res->hasRows()) {
+            for (auto const [nftID] : extract<ripple::uint256>(*res))
                 nftIDs.push_back(nftID);
         }
         return nftIDs;
@@ -229,8 +229,8 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
         firstQuery.bindAt(3, Limit{limit});
 
         auto const firstRes = executor_.read(yield, firstQuery);
-        if (firstRes) {
-            for (auto const [nftID] : extract<ripple::uint256>(firstRes.value()))
+        if (firstRes.has_value()) {
+            for (auto const [nftID] : extract<ripple::uint256>(*firstRes))
                 nftIDs.push_back(nftID);
         }
 
@@ -241,8 +241,8 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
             secondQuery.bindAt(2, Limit{remainingLimit});
 
             auto const secondRes = executor_.read(yield, secondQuery);
-            if (secondRes) {
-                for (auto const [nftID] : extract<ripple::uint256>(secondRes.value()))
+            if (secondRes.has_value()) {
+                for (auto const [nftID] : extract<ripple::uint256>(*secondRes))
                     nftIDs.push_back(nftID);
             }
         }
@@ -291,10 +291,11 @@ class BasicKeyspaceBackend : public CassandraBackendFamily<
 
         // Combine the results into final NFT objects.
         for (auto i = 0u; i < nftIDs.size(); ++i) {
-            if (auto const maybeRow = nftInfos[i].template get<uint32_t, ripple::AccountID, bool>(); maybeRow) {
+            if (auto const maybeRow = nftInfos[i].template get<uint32_t, ripple::AccountID, bool>();
+                maybeRow.has_value()) {
                 auto [seq, owner, isBurned] = *maybeRow;
                 NFT nft(nftIDs[i], seq, owner, isBurned);
-                if (auto const maybeUri = nftUris[i].template get<ripple::Blob>(); maybeUri)
+                if (auto const maybeUri = nftUris[i].template get<ripple::Blob>(); maybeUri.has_value())
                     nft.uri = *maybeUri;
                 ret.nfts.push_back(nft);
             }

src/data/cassandra/CassandraBackendFamily.hpp

@@ -70,10 +70,10 @@ namespace data::cassandra {
  *
  * Note: This is a safer and more correct rewrite of the original implementation of the backend.
  *
- * @tparam SettingsProviderType The settings provider type to use
- * @tparam ExecutionStrategyType The execution strategy type to use
- * @tparam SchemaType The Schema type to use
- * @tparam FetchLedgerCacheType The ledger header cache type to use
+ * @tparam SettingsProviderType The settings provider type
+ * @tparam ExecutionStrategyType The execution strategy type
+ * @tparam SchemaType The Schema type
+ * @tparam FetchLedgerCacheType The ledger header cache type
  */
 template <
     SomeSettingsProvider SettingsProviderType,
@@ -100,8 +100,8 @@ class CassandraBackendFamily : public BackendInterface {
     /**
      * @brief Create a new cassandra/scylla backend instance.
      *
-     * @param settingsProvider The settings provider to use
-     * @param cache The ledger cache to use
+     * @param settingsProvider The settings provider
+     * @param cache The ledger cache
      * @param readOnly Whether the database should be in readonly mode
      */
     CassandraBackendFamily(SettingsProviderType settingsProvider, data::LedgerCacheInterface& cache, bool readOnly)
@@ -111,18 +111,18 @@ class CassandraBackendFamily : public BackendInterface {
         , handle_{settingsProvider_.getSettings()}
         , executor_{settingsProvider_.getSettings(), handle_}
     {
-        if (auto const res = handle_.connect(); not res)
+        if (auto const res = handle_.connect(); not res.has_value())
             throw std::runtime_error("Could not connect to database: " + res.error());
 
         if (not readOnly) {
-            if (auto const res = handle_.execute(schema_.createKeyspace); not res) {
+            if (auto const res = handle_.execute(schema_.createKeyspace); not res.has_value()) {
                 // on datastax, creation of keyspaces can be configured to only be done thru the admin
                 // interface. this does not mean that the keyspace does not already exist tho.
                 if (res.error().code() != CASS_ERROR_SERVER_UNAUTHORIZED)
                     throw std::runtime_error("Could not create keyspace: " + res.error());
             }
 
-            if (auto const res = handle_.executeEach(schema_.createSchema); not res)
+            if (auto const res = handle_.executeEach(schema_.createSchema); not res.has_value())
                 throw std::runtime_error("Could not create schema: " + res.error());
         }
 
@@ -233,10 +233,10 @@ class CassandraBackendFamily : public BackendInterface {
     std::optional<std::uint32_t>
     fetchLatestLedgerSequence(boost::asio::yield_context yield) const override
     {
-        if (auto const res = executor_.read(yield, schema_->selectLatestLedger); res) {
-            if (auto const& result = res.value(); result) {
-                if (auto const maybeValue = result.template get<uint32_t>(); maybeValue)
-                    return maybeValue;
+        if (auto const res = executor_.read(yield, schema_->selectLatestLedger); res.has_value()) {
+            if (auto const& rows = *res; rows) {
+                if (auto const maybeRow = rows.template get<uint32_t>(); maybeRow.has_value())
+                    return maybeRow;
 
                 LOG(log_.error()) << "Could not fetch latest ledger - no rows";
                 return std::nullopt;

src/data/cassandra/SettingsProvider.cpp

@@ -97,7 +97,7 @@ SettingsProvider::parseSettings() const
     settings.coreConnectionsPerHost = config_.get<uint32_t>("core_connections_per_host");
     settings.queueSizeIO = config_.maybeValue<uint32_t>("queue_size_io");
     settings.writeBatchSize = config_.get<std::size_t>("write_batch_size");
-    settings.provider = config_.get<std::string>("provider");
+    settings.provider = impl::providerFromString(config_.get<std::string>("provider"));
 
     if (config_.getValueView("connect_timeout").hasValue()) {
         auto const connectTimeoutSecond = config_.get<uint32_t>("connect_timeout");

src/data/cassandra/impl/Cluster.cpp

@@ -61,7 +61,7 @@ Cluster::Cluster(Settings const& settings) : ManagedObject{cass_cluster_new(), k
     cass_cluster_set_request_timeout(*this, settings.requestTimeout.count());
 
     // TODO: AWS keyspace reads should be local_one to save cost
-    if (settings.provider == toString(cassandra::impl::Provider::Keyspace)) {
+    if (settings.provider == cassandra::impl::Provider::Keyspace) {
         if (auto const rc = cass_cluster_set_consistency(*this, CASS_CONSISTENCY_LOCAL_QUORUM); rc != CASS_OK) {
             throw std::runtime_error(fmt::format("Error setting keyspace consistency: {}", cass_error_desc(rc)));
         }

src/data/cassandra/impl/Cluster.hpp

@@ -20,6 +20,7 @@
 #pragma once
 
 #include "data/cassandra/impl/ManagedObject.hpp"
+#include "util/Assert.hpp"
 #include "util/log/Logger.hpp"
 
 #include <cassandra.h>
@@ -31,29 +32,22 @@
 #include <string>
 #include <string_view>
 #include <thread>
-#include <utility>
 #include <variant>
 
 namespace data::cassandra::impl {
 
-namespace {
-
 enum class Provider { Cassandra, Keyspace };
 
-inline std::string
-toString(Provider provider)
+inline Provider
+providerFromString(std::string const& provider)
 {
-    switch (provider) {
-        case Provider::Cassandra:
-            return "cassandra";
-        case Provider::Keyspace:
-            return "aws_keyspace";
-    }
-    std::unreachable();
+    ASSERT(
+        provider == "cassandra" || provider == "aws_keyspace",
+        "Provider type must be one of 'cassandra' or 'aws_keyspace'"
+    );
+    return provider == "cassandra" ? Provider::Cassandra : Provider::Keyspace;
 }
 
-}  // namespace
-
 // TODO: move Settings to public interface, not impl
 
 /**
@@ -109,7 +103,7 @@ struct Settings {
     std::size_t writeBatchSize = kDEFAULT_BATCH_SIZE;
 
     /** @brief Provider to know if we are using scylladb or keyspace */
-    std::string provider = toString(kDEFAULT_PROVIDER);
+    Provider provider = kDEFAULT_PROVIDER;
 
     /** @brief Size of the IO queue */
     std::optional<uint32_t> queueSizeIO = std::nullopt;  // NOLINT(readability-redundant-member-init)

src/util/config/ConfigConstraints.hpp

@@ -45,7 +45,7 @@ class ConfigValue;
 /**
  * @brief specific values that are accepted for logger levels in config.
  */
-static constexpr std::array<char const*, 6> kLOG_LEVELS = {
+static constexpr std::array<std::string_view, 6> kLOG_LEVELS = {
     "trace",
     "debug",
     "info",
@@ -57,7 +57,7 @@ static constexpr std::array<char const*, 6> kLOG_LEVELS = {
 /**
  * @brief specific values that are accepted for logger tag style in config.
  */
-static constexpr std::array<char const*, 5> kLOG_TAGS = {
+static constexpr std::array<std::string_view, 5> kLOG_TAGS = {
     "int",
     "uint",
     "null",
@@ -68,7 +68,7 @@ static constexpr std::array<char const*, 5> kLOG_TAGS = {
 /**
  * @brief specific values that are accepted for cache loading in config.
  */
-static constexpr std::array<char const*, 3> kLOAD_CACHE_MODE = {
+static constexpr std::array<std::string_view, 3> kLOAD_CACHE_MODE = {
     "sync",
     "async",
     "none",
@@ -77,17 +77,17 @@ static constexpr std::array<char const*, 3> kLOAD_CACHE_MODE = {
 /**
  * @brief specific values that are accepted for database type in config.
  */
-static constexpr std::array<char const*, 1> kDATABASE_TYPE = {"cassandra"};
+static constexpr std::array<std::string_view, 1> kDATABASE_TYPE = {"cassandra"};
 
 /**
  * @brief specific values that are accepted for server's processing_policy in config.
  */
-static constexpr std::array<char const*, 2> kPROCESSING_POLICY = {"parallel", "sequent"};
+static constexpr std::array<std::string_view, 2> kPROCESSING_POLICY = {"parallel", "sequent"};
 
 /**
  * @brief specific values that are accepted for database provider in config.
  */
-static constexpr std::array<char const*, 2> kPROVIDER = {"cassandra", "aws_keyspace"};
+static constexpr std::array<std::string_view, 2> kPROVIDER = {"cassandra", "aws_keyspace"};
 
 /**
  * @brief An interface to enforce constraints on certain values within ClioConfigDefinition.
@@ -123,7 +123,7 @@ class Constraint {
      */
     template <std::size_t ArrSize>
     constexpr std::string
-    makeErrorMsg(std::string_view key, Value const& value, std::array<char const*, ArrSize> arr) const
+    makeErrorMsg(std::string_view key, Value const& value, std::array<std::string_view, ArrSize> arr) const
     {
         // Extract the value from the variant
         auto const valueStr = std::visit([](auto const& v) { return fmt::format("{}", v); }, value);
@@ -271,7 +271,7 @@ class OneOf final : public Constraint {
      * @param key The key of the ConfigValue that has this constraint
      * @param arr The value that has this constraint must be of the values in arr
      */
-    constexpr OneOf(std::string_view key, std::array<char const*, ArrSize> arr) : key_{key}, arr_{arr}
+    constexpr OneOf(std::string_view key, std::array<std::string_view, ArrSize> arr) : key_{key}, arr_{arr}
     {
     }
 
@@ -318,7 +318,7 @@ class OneOf final : public Constraint {
     print(std::ostream& stream) const override
     {
         std::string valuesStream;
-        std::ranges::for_each(arr_, [&valuesStream](std::string const& elem) {
+        std::ranges::for_each(arr_, [&valuesStream](std::string_view elem) {
             valuesStream += fmt::format(" `{}`,", elem);
         });
         // replace the last "," with "."
@@ -327,7 +327,7 @@ class OneOf final : public Constraint {
     }
 
     std::string_view key_;
-    std::array<char const*, ArrSize> arr_;
+    std::array<std::string_view, ArrSize> arr_;
 };
 
 /**