22#include "rpc/common/APIVersion.hpp" 
   23#include "util/config/Error.hpp" 
   24#include "util/config/Types.hpp" 
   25#include "util/log/Logger.hpp" 
   27#include <fmt/format.h> 
   28#include <fmt/ranges.h> 
   41namespace util::config {
 
   48static constexpr std::array<std::string_view, 6> kLOG_LEVELS = {
 
   60static constexpr std::array<std::string_view, 5> kLOG_TAGS = {
 
   71static constexpr std::array<std::string_view, 3> kLOAD_CACHE_MODE = {
 
   80static constexpr std::array<std::string_view, 1> kDATABASE_TYPE = {
"cassandra"};
 
   85static constexpr std::array<std::string_view, 2> kPROCESSING_POLICY = {
"parallel", 
"sequent"};
 
   90static constexpr std::array<std::string_view, 2> kPROVIDER = {
"cassandra", 
"aws_keyspace"};
 
  109        if (
auto const maybeError = 
checkTypeImpl(val); maybeError.has_value())
 
 
  124    template <std::
size_t ArrSize>
 
  125    constexpr std::string
 
  126    makeErrorMsg(std::string_view key, Value 
const& value, std::array<std::string_view, ArrSize> arr)
 const 
  129        auto const valueStr = std::visit([](
auto const& v) { 
return fmt::format(
"{}", v); }, value);
 
  133            R
"(You provided value "{}". Key "{}"'s value must be one of the following: {})", 
 
  146    virtual std::optional<Error>
 
  155    virtual std::optional<Error>
 
  164    print(std::ostream& stream) 
const = 0;
 
 
  195    [[nodiscard]] std::optional<Error>
 
  196    checkTypeImpl(Value 
const& port) 
const override;
 
  204    [[nodiscard]] std::optional<Error>
 
  205    checkValueImpl(Value 
const& port) 
const override;
 
  213    print(std::ostream& stream)
 const override 
  215        stream << fmt::format(
"The minimum value is `{}`. The maximum value is `{}`.", kPORT_MIN, kPORT_MAX);
 
  218    static constexpr uint32_t kPORT_MIN = 1;
 
  219    static constexpr uint32_t kPORT_MAX = 65535;
 
 
  236    [[nodiscard]] std::optional<Error>
 
  237    checkTypeImpl(Value 
const& ip) 
const override;
 
  245    [[nodiscard]] std::optional<Error>
 
  246    checkValueImpl(Value 
const& ip) 
const override;
 
  254    print(std::ostream& stream)
 const override 
  256        stream << 
"The value must be a valid IP address.";
 
 
  265template <std::
size_t ArrSize>
 
  274    constexpr OneOf(std::string_view key, std::array<std::string_view, ArrSize> arr) : key_{key}, arr_{arr}
 
 
  278    constexpr ~OneOf() noexcept override = default;
 
  287    [[nodiscard]] std::optional<
Error>
 
  288    checkTypeImpl(Value const& val)
 const override 
  290        if (!std::holds_alternative<std::string>(val))
 
  291            return Error{fmt::format(R
"(Key "{}"'s value must be a string)", key_)}; 
  301    [[nodiscard]] std::optional<Error>
 
  302    checkValueImpl(Value 
const& val)
 const override 
  304        namespace rg = std::ranges;
 
  305        auto const check = [&val](std::string_view name) { 
return std::get<std::string>(val) == name; };
 
  306        if (rg::any_of(arr_, check))
 
  318    print(std::ostream& stream)
 const override 
  320        std::string valuesStream;
 
  321        std::ranges::for_each(arr_, [&valuesStream](std::string_view elem) {
 
  322            valuesStream += fmt::format(
" `{}`,", elem);
 
  325        valuesStream.back() = 
'.';
 
  326        stream << fmt::format(
"The value must be one of the following:{}", valuesStream);
 
  329    std::string_view key_;
 
  330    std::array<std::string_view, ArrSize> arr_;
 
 
  336template <
typename NumType>
 
  358    [[nodiscard]] std::optional<
Error>
 
  359    checkTypeImpl(Value const& num)
 const override 
  361        if (!std::holds_alternative<int64_t>(num))
 
  362            return Error{
"Number must be of type integer"};
 
  372    [[nodiscard]] std::optional<Error>
 
  373    checkValueImpl(Value 
const& num)
 const override 
  375        auto const numValue = std::get<int64_t>(num);
 
  376        if (numValue >= 
static_cast<int64_t
>(min_) && numValue <= 
static_cast<int64_t
>(max_))
 
  378        return Error{fmt::format(
"Number must be between {} and {}", min_, max_)};
 
  387    print(std::ostream& stream)
 const override 
  389        stream << fmt::format(
"The minimum value is `{}`. The maximum value is `{}`.", min_, max_);
 
 
  410    [[nodiscard]] std::optional<Error>
 
  411    checkTypeImpl(Value 
const& num) 
const override;
 
  419    [[nodiscard]] std::optional<Error>
 
  420    checkValueImpl(Value 
const& num) 
const override;
 
  428    print(std::ostream& stream)
 const override 
  430        stream << 
"The value must be a positive double number.";
 
 
  445    [[nodiscard]] std::optional<Error>
 
  446    checkTypeImpl(Value 
const& value) 
const override;
 
  454    [[nodiscard]] std::optional<Error>
 
  455    checkValueImpl(Value 
const& value) 
const override;
 
  463    print(std::ostream& stream)
 const override 
  465        stream << 
"Checks whether provided RPC name is valid";
 
 
  470static constinit ValidIPConstraint gValidateIp{};
 
  472static constinit OneOf gValidateChannelName{
"channel", Logger::kCHANNELS};
 
  473static constinit OneOf gValidateLogLevelName{
"log.level", kLOG_LEVELS};
 
  474static constinit OneOf gValidateCassandraName{
"database.type", kDATABASE_TYPE};
 
  475static constinit OneOf gValidateLoadMode{
"cache.load", kLOAD_CACHE_MODE};
 
  476static constinit OneOf gValidateLogTag{
"log.tag_style", kLOG_TAGS};
 
  477static constinit OneOf gValidateProcessingPolicy{
"server.processing_policy", kPROCESSING_POLICY};
 
  478static constinit OneOf gValidateProvider{
"database.cassandra.provider", kPROVIDER};
 
Represents the config values for Json/Yaml config.
Definition ConfigValue.hpp:47
An interface to enforce constraints on certain values within ClioConfigDefinition.
Definition ConfigConstraints.hpp:95
friend std::ostream & operator<<(std::ostream &stream, Constraint const &cons)
Custom output stream for constraint.
Definition ConfigConstraints.hpp:174
virtual void print(std::ostream &stream) const =0
Prints to the output stream for this specific constraint.
virtual std::optional< Error > checkValueImpl(Value const &val) const =0
Check if the value is within the constraint.
constexpr std::string makeErrorMsg(std::string_view key, Value const &value, std::array< std::string_view, ArrSize > arr) const
Creates an error message for all constraints that must satisfy certain hard-coded values.
Definition ConfigConstraints.hpp:126
std::optional< Error > checkConstraint(Value const &val) const
Check if the value meets the specific constraint.
Definition ConfigConstraints.hpp:107
virtual std::optional< Error > checkTypeImpl(Value const &val) const =0
Check if the value is of a correct type for the constraint.
A constraint class to ensure an integer value is between two numbers (inclusive).
Definition ConfigConstraints.hpp:337
constexpr NumberValueConstraint(NumType min, NumType max)
Constructs a constraint where the number must be between min_ and max_.
Definition ConfigConstraints.hpp:345
A constraint class to ensure the provided value is one of the specified values in an array.
Definition ConfigConstraints.hpp:266
constexpr OneOf(std::string_view key, std::array< std::string_view, ArrSize > arr)
Constructs a constraint where the value must be one of the values in the provided array.
Definition ConfigConstraints.hpp:274
A constraint to ensure the port number is within a valid range.
Definition ConfigConstraints.hpp:184
A constraint to ensure a double number is positive.
Definition ConfigConstraints.hpp:399
A constraint to ensure the value is a valid RPC command name.
Definition ConfigConstraints.hpp:437
A constraint to ensure the IP address is valid.
Definition ConfigConstraints.hpp:225
Provides view into ConfigValues that represents values in Clio Config.
Definition ValueView.hpp:46
static constexpr uint32_t kAPI_VERSION_MIN
Minimum API version supported by this build.
Definition APIVersion.hpp:38
static constexpr uint32_t kAPI_VERSION_MAX
Maximum API version supported by this build.
Definition APIVersion.hpp:43
Displays the different errors when parsing user config.
Definition Error.hpp:31