ConfigConstraints.hpp

//------------------------------------------------------------------------------
/*
   This file is part of clio: https://github.com/XRPLF/clio
   Copyright (c) 2024, the clio developers.
 
   Permission to use, copy, modify, and distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
   copyright notice and this permission notice appear in all copies.
 
   THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
   MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#pragma once
 
#include "rpc/common/APIVersion.hpp"
#include "util/log/Logger.hpp"
#include "util/newconfig/Error.hpp"
#include "util/newconfig/Types.hpp"
 
#include <fmt/core.h>
#include <fmt/format.h>
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <variant>
 
namespace util::config {
class ValueView;
class ConfigValue;
 
static constexpr std::array<char const*, 7> kLOG_LEVELS = {
    "trace",
    "debug",
    "info",
    "warning",
    "error",
    "fatal",
    "count",
};
 
static constexpr std::array<char const*, 5> kLOG_TAGS = {
    "int",
    "uint",
    "null",
    "none",
    "uuid",
};
 
static constexpr std::array<char const*, 3> kLOAD_CACHE_MODE = {
    "sync",
    "async",
    "none",
};
 
static constexpr std::array<char const*, 1> kDATABASE_TYPE = {"cassandra"};
 
static constexpr std::array<char const*, 2> kPROCESSING_POLICY = {"parallel", "sequent"};
 
class Constraint {
public:
    constexpr virtual ~Constraint() noexcept = default;
 
    [[nodiscard]]
    std::optional<Error>
    checkConstraint(Value const& val) const
    {
        if (auto const maybeError = checkTypeImpl(val); maybeError.has_value())
            return maybeError;
        return checkValueImpl(val);
    }
 
protected:
    template <std::size_t ArrSize>
    constexpr std::string
    makeErrorMsg(std::string_view key, Value const& value, std::array<char const*, ArrSize> arr) const
    {
        // Extract the value from the variant
        auto const valueStr = std::visit([](auto const& v) { return fmt::format("{}", v); }, value);
 
        // Create the error message
        return fmt::format(
            R"(You provided value "{}". Key "{}"'s value must be one of the following: {})",
            valueStr,
            key,
            fmt::join(arr, ", ")
        );
    }
 
    virtual std::optional<Error>
    checkTypeImpl(Value const& val) const = 0;
 
    virtual std::optional<Error>
    checkValueImpl(Value const& val) const = 0;
 
    virtual void
    print(std::ostream& stream) const = 0;
 
    friend std::ostream&
    operator<<(std::ostream& stream, Constraint const& cons)
    {
        cons.print(stream);
        return stream;
    }
};
 
class PortConstraint final : public Constraint {
public:
    constexpr ~PortConstraint() noexcept override = default;
 
private:
    [[nodiscard]] std::optional<Error>
    checkTypeImpl(Value const& port) const override;
 
    [[nodiscard]] std::optional<Error>
    checkValueImpl(Value const& port) const override;
 
    void
    print(std::ostream& stream) const override
    {
        stream << fmt::format("The minimum value is `{}`. The maximum value is `{}`.", kPORT_MIN, kPORT_MAX);
    }
 
    static constexpr uint32_t kPORT_MIN = 1;
    static constexpr uint32_t kPORT_MAX = 65535;
};
 
class ValidIPConstraint final : public Constraint {
public:
    constexpr ~ValidIPConstraint() noexcept override = default;
 
private:
    [[nodiscard]] std::optional<Error>
    checkTypeImpl(Value const& ip) const override;
 
    [[nodiscard]] std::optional<Error>
    checkValueImpl(Value const& ip) const override;
 
    void
    print(std::ostream& stream) const override
    {
        stream << "The value must be a valid IP address.";
    }
};
 
template <std::size_t ArrSize>
class OneOf final : public Constraint {
public:
    constexpr OneOf(std::string_view key, std::array<char const*, ArrSize> arr) : key_{key}, arr_{arr}
    {
    }
 
    constexpr ~OneOf() noexcept override = default;
 
private:
    [[nodiscard]] std::optional<Error>
    checkTypeImpl(Value const& val) const override
    {
        if (!std::holds_alternative<std::string>(val))
            return Error{fmt::format(R"(Key "{}"'s value must be a string)", key_)};
        return std::nullopt;
    }
 
    [[nodiscard]] std::optional<Error>
    checkValueImpl(Value const& val) const override
    {
        namespace rg = std::ranges;
        auto const check = [&val](std::string_view name) { return std::get<std::string>(val) == name; };
        if (rg::any_of(arr_, check))
            return std::nullopt;
 
        return Error{makeErrorMsg(key_, val, arr_)};
    }
 
    void
    print(std::ostream& stream) const override
    {
        std::string valuesStream;
        std::ranges::for_each(arr_, [&valuesStream](std::string const& elem) {
            valuesStream += fmt::format(" `{}`,", elem);
        });
        // replace the last "," with "."
        valuesStream.back() = '.';
        stream << fmt::format("The value must be one of the following:{}", valuesStream);
    }
 
    std::string_view key_;
    std::array<char const*, ArrSize> arr_;
};
 
template <typename NumType>
class NumberValueConstraint final : public Constraint {
public:
    constexpr NumberValueConstraint(NumType min, NumType max) : min_{min}, max_{max}
    {
    }
 
    constexpr ~NumberValueConstraint() noexcept override = default;
 
private:
    [[nodiscard]] std::optional<Error>
    checkTypeImpl(Value const& num) const override
    {
        if (!std::holds_alternative<int64_t>(num))
            return Error{"Number must be of type integer"};
        return std::nullopt;
    }
 
    [[nodiscard]] std::optional<Error>
    checkValueImpl(Value const& num) const override
    {
        auto const numValue = std::get<int64_t>(num);
        if (numValue >= static_cast<int64_t>(min_) && numValue <= static_cast<int64_t>(max_))
            return std::nullopt;
        return Error{fmt::format("Number must be between {} and {}", min_, max_)};
    }
 
    void
    print(std::ostream& stream) const override
    {
        stream << fmt::format("The minimum value is `{}`. The maximum value is `{}`.", min_, max_);
    }
 
    NumType min_;
    NumType max_;
};
 
class PositiveDouble final : public Constraint {
public:
    constexpr ~PositiveDouble() noexcept override = default;
 
private:
    [[nodiscard]] std::optional<Error>
    checkTypeImpl(Value const& num) const override;
 
    [[nodiscard]] std::optional<Error>
    checkValueImpl(Value const& num) const override;
 
    void
    print(std::ostream& stream) const override
    {
        stream << "The value must be a positive double number.";
    }
};
 
static constinit PortConstraint gValidatePort{};
static constinit ValidIPConstraint gValidateIp{};
 
static constinit OneOf gValidateChannelName{"channel", Logger::kCHANNELS};
static constinit OneOf gValidateLogLevelName{"log_level", kLOG_LEVELS};
static constinit OneOf gValidateCassandraName{"database.type", kDATABASE_TYPE};
static constinit OneOf gValidateLoadMode{"cache.load", kLOAD_CACHE_MODE};
static constinit OneOf gValidateLogTag{"log_tag_style", kLOG_TAGS};
static constinit OneOf gValidateProcessingPolicy{"server.processing_policy", kPROCESSING_POLICY};
 
static constinit PositiveDouble gValidatePositiveDouble{};
 
static constinit NumberValueConstraint<uint16_t> gValidateNumMarkers{1, 256};
static constinit NumberValueConstraint<uint16_t> gValidateNumCursors{0, std::numeric_limits<uint16_t>::max()};
 
// replication factor can be 0
static constinit NumberValueConstraint<uint16_t> gValidateReplicationFactor{0, std::numeric_limits<uint16_t>::max()};
 
static constinit NumberValueConstraint<uint16_t> gValidateUint16{1, std::numeric_limits<uint16_t>::max()};
 
static constinit NumberValueConstraint<uint32_t> gValidateUint32{1, std::numeric_limits<uint32_t>::max()};
static constinit NumberValueConstraint<uint32_t> gValidateApiVersion{rpc::kAPI_VERSION_MIN, rpc::kAPI_VERSION_MAX};
 
}  // namespace util::config