configuration.h

Go to the documentation of this file.

#pragma once
 
#include <cstdlib>
#include <filesystem>
#include <string>
#include <string_view>
 
#include "cppfig/conf.h"
#include "cppfig/diff.h"
#include "cppfig/interface.h"
#include "cppfig/logging.h"
#include "cppfig/serializer.h"
#include "cppfig/setting.h"
#include "cppfig/thread_policy.h"
#include "cppfig/traits.h"
#include "cppfig/value.h"
 
namespace cppfig {
 
template <typename Schema, Serializer SerializerT = ConfSerializer, typename ThreadPolicy = SingleThreadedPolicy>
class Configuration : public IConfigurationProvider<Configuration<Schema, SerializerT, ThreadPolicy>, Schema> {
public:
    using serializer_type = SerializerT;
    using data_type = Value;
 
    explicit Configuration(std::string file_path)
        : file_path_(std::move(file_path))
        , file_values_(Value::Object())
    {
        BuildDefaults();
    }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    [[nodiscard]] auto GetImpl() const -> typename S::value_type
    {
        using value_type = typename S::value_type;
 
        // 1. Check environment variable (no lock needed — no mutable state accessed)
        constexpr auto env_override = GetEnvOverride<S>();
        if constexpr (!env_override.empty()) {
            if (const char* env_value = std::getenv(std::string(env_override).c_str())) {
                auto parsed = ConfigTraits<value_type>::FromString(env_value);
                if (!parsed.has_value()) {
                    Logger::WarnF("Failed to parse environment variable %.*s='%s', using fallback",
                                  static_cast<int>(env_override.size()), env_override.data(), env_value);
                }
                else {
                    // An override that fails the setting's own validator must
                    // not slip through unchecked; fall back and say so.
                    auto validation = GetSettingValidator<S>()(*parsed);
                    if (validation) {
                        return *parsed;
                    }
                    Logger::WarnF("Environment variable %.*s='%s' is invalid (%s), using fallback",
                                  static_cast<int>(env_override.size()), env_override.data(), env_value,
                                  validation.error_message.c_str());
                }
            }
        }
 
        // 2. Check file value (shared lock — concurrent readers allowed)
        {
            typename ThreadPolicy::shared_lock lock(mutex_);
            auto file_result = file_values_.GetAtPath(S::path);
            if (file_result.ok()) {
                auto parsed = ConfigTraits<value_type>::Deserialize(*file_result);
                if (parsed.has_value()) {
                    return *parsed;
                }
                Logger::WarnF("Failed to parse file value for '%.*s', using default",
                              static_cast<int>(S::path.size()), S::path.data());
            }
        }
 
        // 3. Return default value (immutable after construction — no lock needed)
        return S::default_value();
    }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    [[nodiscard]] auto IsOverriddenImpl() const -> bool
    {
        constexpr auto env_override = GetEnvOverride<S>();
        if constexpr (env_override.empty()) {
            return false;
        }
        else {
            return std::getenv(std::string(env_override).c_str()) != nullptr;
        }
    }
 
    template <IsSetting S>
        requires(Schema::template has_setting<S>)
    auto SetImpl(typename S::value_type value) -> Status
    {
        using value_type = typename S::value_type;
 
        // Validate the value *before* acquiring the exclusive lock
        auto validator = GetSettingValidator<S>();
        auto validation = validator(value);
        if (!validation) {
            return InvalidArgumentError(validation.error_message);
        }
 
        // Returning OK from a write the next read will ignore is a trap.
        constexpr auto env_override = GetEnvOverride<S>();
        if constexpr (!env_override.empty()) {
            if (IsOverriddenImpl<S>()) {
                Logger::WarnF("Set('%.*s') stored, but %.*s is overriding it and Get will return the override",
                              static_cast<int>(S::path.size()), S::path.data(),
                              static_cast<int>(env_override.size()), env_override.data());
            }
        }
 
        // Set the value under exclusive lock
        typename ThreadPolicy::unique_lock lock(mutex_);
        auto serialized = ConfigTraits<value_type>::Serialize(value);
        file_values_.SetAtPath(S::path, serialized);
 
        return OkStatus();
    }
 
    [[nodiscard]] auto LoadImpl() -> Status
    {
        typename ThreadPolicy::unique_lock lock(mutex_);
        return LoadUnlocked();
    }
 
    [[nodiscard]] auto SaveImpl() const -> Status
    {
        typename ThreadPolicy::unique_lock lock(mutex_);
        return SaveUnlocked();
    }
 
    [[nodiscard]] auto DiffImpl() const -> ConfigDiff
    {
        typename ThreadPolicy::shared_lock lock(mutex_);
        return DiffFileFromDefaults(defaults_, file_values_);
    }
 
    [[nodiscard]] auto ValidateAllImpl() const -> Status
    {
        typename ThreadPolicy::shared_lock lock(mutex_);
        return ValidateAllUnlocked();
    }
 
    [[nodiscard]] auto GetFilePathImpl() const -> std::string_view { return file_path_; }
 
    [[nodiscard]] auto GetFileValues() const -> Value
    {
        typename ThreadPolicy::shared_lock lock(mutex_);
        return file_values_;
    }
 
    [[nodiscard]] auto GetDefaults() const -> Value { return defaults_; }
 
private:
    [[nodiscard]] auto LoadUnlocked() -> Status
    {
        namespace fs = std::filesystem;
 
        if (!fs::exists(file_path_)) {
            // File doesn't exist - create with defaults
            Logger::InfoF("Configuration file '%s' not found, creating with defaults", file_path_.c_str());
            file_values_ = defaults_;
            auto save_status = SaveUnlocked();
            if (!save_status.ok()) {
                return save_status;
            }
            return ValidateFileValuesUnlocked();
        }
 
        // Load existing file
        auto result = ReadFile<SerializerT>(file_path_);
        if (!result.ok()) {
            return result.status();
        }
 
        file_values_ = *result;
        CoerceToSchemaTypes();
 
        // Check for schema migration (new settings in defaults not in file)
        auto diff = DiffDefaultsFromFile(defaults_, file_values_);
        auto added = diff.Added();
 
        if (!added.empty()) {
            Logger::Warn("New settings detected in schema, adding to configuration file:");
            for (const auto& entry : added) {
                Logger::WarnF("  - %s = %s", entry.path.c_str(), entry.new_value.c_str());
                // Copy the default value directly from the defaults tree
                auto default_val = defaults_.GetAtPath(entry.path);
                if (default_val.ok()) {
                    file_values_.SetAtPath(entry.path, *default_val);
                }
            }
 
            // Save the updated configuration
            auto save_status = SaveUnlocked();
            if (!save_status.ok()) {
                Logger::ErrorF("Failed to save migrated configuration: %s",
                               std::string(save_status.message()).c_str());
                return save_status;
            }
        }
 
        // A successful Load must leave the configuration holding only values
        // the schema accepts; otherwise every caller of Get inherits an
        // invalid value that nothing ever objected to.
        return ValidateFileValuesUnlocked();
    }
 
    [[nodiscard]] auto SaveUnlocked() const -> Status
    {
        namespace fs = std::filesystem;
 
        // Create parent directories if needed
        fs::path path(file_path_);
        if (path.has_parent_path()) {
            std::error_code error_code;
            fs::create_directories(path.parent_path(), error_code);
            if (error_code) {
                return InternalError("Failed to create directory: " + error_code.message());
            }
        }
 
        return WriteFile<SerializerT>(file_path_, file_values_);
    }
 
    [[nodiscard]] auto ValidateFileValuesUnlocked() const -> Status
    {
        Status status = OkStatus();
 
        Schema::ForEachSetting([this, &status]<typename S>() {
            if (!status.ok()) {
                return;  // Stop on first error
            }
 
            using value_type = typename S::value_type;
            auto file_result = file_values_.GetAtPath(S::path);
            if (!file_result.ok()) {
                return;
            }
 
            auto parsed = ConfigTraits<value_type>::Deserialize(*file_result);
            if (!parsed.has_value()) {
                return;
            }
 
            auto validation = GetSettingValidator<S>()(*parsed);
            if (!validation) {
                status = InvalidArgumentError(std::string(S::path) + ": " + validation.error_message);
            }
        });
 
        return status;
    }
 
    [[nodiscard]] auto ValidateAllUnlocked() const -> Status
    {
        Status status = ValidateEnvOverridesUnlocked();
        if (!status.ok()) {
            return status;
        }
        return ValidateFileValuesUnlocked();
    }
 
    [[nodiscard]] auto ValidateEnvOverridesUnlocked() const -> Status
    {
        Status status = OkStatus();
 
        Schema::ForEachSetting([&status]<typename S>() {
            if (!status.ok()) {
                return;  // Stop on first error
            }
 
            constexpr auto env_override = GetEnvOverride<S>();
            if constexpr (!env_override.empty()) {
                const char* env_value = std::getenv(std::string(env_override).c_str());
                if (env_value == nullptr) {
                    return;
                }
 
                using value_type = typename S::value_type;
                auto parsed = ConfigTraits<value_type>::FromString(env_value);
                if (!parsed.has_value()) {
                    status = InvalidArgumentError(std::string(env_override) + ": cannot parse '" + env_value + "' as a value for '" + std::string(S::path) + "'");
                    return;
                }
 
                auto validation = GetSettingValidator<S>()(*parsed);
                if (!validation) {
                    status = InvalidArgumentError(std::string(env_override) + ": " + validation.error_message);
                }
            }
        });
 
        return status;
    }
 
    void CoerceToSchemaTypes()
    {
        Schema::ForEachSetting([this]<typename S>() {
            using value_type = typename S::value_type;
 
            auto file_result = file_values_.GetAtPath(S::path);
            if (!file_result.ok()) {
                return;
            }
            if (ConfigTraits<value_type>::Deserialize(*file_result).has_value()) {
                return;
            }
 
            auto text = file_result->TryToText();
            if (!text.has_value()) {
                return;
            }
 
            auto parsed = ConfigTraits<value_type>::FromString(*text);
            if (parsed.has_value()) {
                file_values_.SetAtPath(S::path, ConfigTraits<value_type>::Serialize(*parsed));
            }
        });
    }
 
    void BuildDefaults()
    {
        defaults_ = Value::Object();
 
        Schema::ForEachSetting([this]<typename S>() {
            using value_type = typename S::value_type;
            auto serialized = ConfigTraits<value_type>::Serialize(S::default_value());
            defaults_.SetAtPath(S::path, serialized);
        });
    }
 
    std::string file_path_;
    Value file_values_;
    Value defaults_;
    mutable typename ThreadPolicy::mutex_type mutex_;
};
 
}  // namespace cppfig