ConfigConstraints.hpp

#pragma once
 
#include "rpc/common/APIVersion.hpp"
#include "util/config/Error.hpp"
#include "util/config/Types.hpp"
#include "util/log/Logger.hpp"
 
#include <fmt/format.h>
#include <fmt/ranges.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<std::string_view, 6> kLogLevels = {
    "trace",
    "debug",
    "info",
    "warning",
    "error",
    "fatal",
};

static constexpr std::array<std::string_view, 5> kLogTags = {
    "int",
    "uint",
    "null",
    "none",
    "uuid",
};

static constexpr std::array<std::string_view, 3> kLoadCacheMode = {
    "sync",
    "async",
    "none",
};

static constexpr std::array<std::string_view, 1> kDatabaseType = {"cassandra"};

static constexpr std::array<std::string_view, 2> kProcessingPolicy = {"parallel", "sequent"};

static constexpr std::array<std::string_view, 2> kProvider = {"cassandra", "aws_keyspace"};

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>
    [[nodiscard]] constexpr std::string
    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);
 
        // 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, ", ")
        );
    }

    [[nodiscard]] virtual std::optional<Error>
    checkTypeImpl(Value const& val) const = 0;

    [[nodiscard]] 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 `{}`.", kPortMin, kPortMax
        );
    }
 
    static constexpr uint32_t kPortMin = 1;
    static constexpr uint32_t kPortMax = 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<std::string_view, 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_view 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<std::string_view, 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.";
    }
};

class RpcNameConstraint final : public Constraint {
private:
    [[nodiscard]] std::optional<Error>
    checkTypeImpl(Value const& value) const override;

    [[nodiscard]] std::optional<Error>
    checkValueImpl(Value const& value) const override;

    void
    print(std::ostream& stream) const override
    {
        stream << "Checks whether provided RPC name is valid";
    }
};
 
static constinit PortConstraint gValidatePort{};
static constinit ValidIPConstraint gValidateIp{};
 
static constinit OneOf gValidateChannelName{"channel", Logger::kChannels};
static constinit OneOf gValidateLogLevelName{"log.level", kLogLevels};
static constinit OneOf gValidateCassandraName{"database.type", kDatabaseType};
static constinit OneOf gValidateLoadMode{"cache.load", kLoadCacheMode};
static constinit OneOf gValidateLogTag{"log.tag_style", kLogTags};
static constinit OneOf gValidateProcessingPolicy{"server.processing_policy", kProcessingPolicy};
static constinit OneOf gValidateProvider{"database.cassandra.provider", kProvider};
 
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> gValidateNonNegativeUint32{
    0,
    std::numeric_limits<uint32_t>::max()
};
static constinit NumberValueConstraint<uint32_t> gValidateApiVersion{
    rpc::kApiVersionMin,
    rpc::kApiVersionMax
};
 
static constinit RpcNameConstraint gRpcNameConstraint{};
}  // namespace util::config