system_bootstrapper.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "../interfaces/global_logger_registry.h"
#include "../di/service_container.h"
#include "../patterns/result.h"
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <utility>
#include <vector>
 
namespace kcenon::common::bootstrap {
 
class SystemBootstrapper {
public:
    SystemBootstrapper() = default;
 
    ~SystemBootstrapper();
 
    // Non-copyable
    SystemBootstrapper(const SystemBootstrapper&) = delete;
    SystemBootstrapper& operator=(const SystemBootstrapper&) = delete;
 
    // Movable
    SystemBootstrapper(SystemBootstrapper&& other) noexcept;
    SystemBootstrapper& operator=(SystemBootstrapper&& other) noexcept;
 
    // =========================================================================
    // Fluent Configuration API
    // =========================================================================
 
    SystemBootstrapper& with_default_logger(interfaces::LoggerFactory factory);
 
    SystemBootstrapper& with_logger(const std::string& name,
                                     interfaces::LoggerFactory factory);
 
    SystemBootstrapper& on_initialize(std::function<void()> callback);
 
    SystemBootstrapper& on_shutdown(std::function<void()> callback);
 
    // =========================================================================
    // Security Configuration
    // =========================================================================
 
    SystemBootstrapper& with_auto_freeze(bool freeze_logger_registry = true,
                                         bool freeze_service_container = true);
 
    // =========================================================================
    // Lifecycle Management
    // =========================================================================
 
    VoidResult initialize();
 
    void shutdown();
 
    bool is_initialized() const noexcept;
 
    void reset();
 
private:
    VoidResult register_loggers();
 
    void execute_init_callbacks();
 
    void execute_shutdown_callbacks();
 
    void clear_loggers();
 
    // Configuration state
    interfaces::LoggerFactory default_logger_factory_;
    std::vector<std::pair<std::string, interfaces::LoggerFactory>> named_logger_factories_;
    std::vector<std::function<void()>> init_callbacks_;
    std::vector<std::function<void()>> shutdown_callbacks_;
 
    // Security configuration
    bool auto_freeze_logger_registry_ = false;
    bool auto_freeze_service_container_ = false;
 
    // Lifecycle state
    bool initialized_ = false;
    mutable std::mutex state_mutex_;
};
 
// =============================================================================
// SystemBootstrapper Implementation
// =============================================================================
 
inline SystemBootstrapper::~SystemBootstrapper() {
    if (initialized_) {
        shutdown();
    }
}
 
inline SystemBootstrapper::SystemBootstrapper(SystemBootstrapper&& other) noexcept
    : default_logger_factory_(std::move(other.default_logger_factory_))
    , named_logger_factories_(std::move(other.named_logger_factories_))
    , init_callbacks_(std::move(other.init_callbacks_))
    , shutdown_callbacks_(std::move(other.shutdown_callbacks_))
    , auto_freeze_logger_registry_(other.auto_freeze_logger_registry_)
    , auto_freeze_service_container_(other.auto_freeze_service_container_)
    , initialized_(other.initialized_) {
    other.initialized_ = false;  // Prevent double shutdown
}
 
inline SystemBootstrapper& SystemBootstrapper::operator=(
    SystemBootstrapper&& other) noexcept {
    if (this != &other) {
        // Shutdown current state if initialized
        if (initialized_) {
            shutdown();
        }
 
        default_logger_factory_ = std::move(other.default_logger_factory_);
        named_logger_factories_ = std::move(other.named_logger_factories_);
        init_callbacks_ = std::move(other.init_callbacks_);
        shutdown_callbacks_ = std::move(other.shutdown_callbacks_);
        auto_freeze_logger_registry_ = other.auto_freeze_logger_registry_;
        auto_freeze_service_container_ = other.auto_freeze_service_container_;
        initialized_ = other.initialized_;
        other.initialized_ = false;  // Prevent double shutdown
    }
    return *this;
}
 
inline SystemBootstrapper& SystemBootstrapper::with_default_logger(
    interfaces::LoggerFactory factory) {
    default_logger_factory_ = std::move(factory);
    return *this;
}
 
inline SystemBootstrapper& SystemBootstrapper::with_logger(
    const std::string& name,
    interfaces::LoggerFactory factory) {
    // Check if name already exists and update, otherwise add
    for (auto& entry : named_logger_factories_) {
        if (entry.first == name) {
            entry.second = std::move(factory);
            return *this;
        }
    }
    named_logger_factories_.emplace_back(name, std::move(factory));
    return *this;
}
 
inline SystemBootstrapper& SystemBootstrapper::on_initialize(
    std::function<void()> callback) {
    if (callback) {
        init_callbacks_.push_back(std::move(callback));
    }
    return *this;
}
 
inline SystemBootstrapper& SystemBootstrapper::on_shutdown(
    std::function<void()> callback) {
    if (callback) {
        shutdown_callbacks_.push_back(std::move(callback));
    }
    return *this;
}
 
inline SystemBootstrapper& SystemBootstrapper::with_auto_freeze(
    bool freeze_logger_registry,
    bool freeze_service_container) {
    auto_freeze_logger_registry_ = freeze_logger_registry;
    auto_freeze_service_container_ = freeze_service_container;
    return *this;
}
 
inline VoidResult SystemBootstrapper::initialize() {
    std::lock_guard<std::mutex> lock(state_mutex_);
 
    if (initialized_) {
        return make_error<std::monostate>(
            error_codes::ALREADY_EXISTS,
            "SystemBootstrapper already initialized",
            "bootstrap::SystemBootstrapper"
        );
    }
 
    // Step 1: Register all loggers
    auto result = register_loggers();
    if (result.is_err()) {
        return result;
    }
 
    // Step 2: Execute initialization callbacks
    execute_init_callbacks();
 
    // Step 3: Freeze registries if auto-freeze is enabled
    if (auto_freeze_logger_registry_) {
        interfaces::GlobalLoggerRegistry::instance().freeze();
    }
    if (auto_freeze_service_container_) {
        di::service_container::global().freeze();
    }
 
    // Step 4: Mark as initialized
    initialized_ = true;
 
    return VoidResult::ok({});
}
 
inline void SystemBootstrapper::shutdown() {
    std::lock_guard<std::mutex> lock(state_mutex_);
 
    if (!initialized_) {
        return;  // Already shutdown or never initialized
    }
 
    // Step 1: Execute shutdown callbacks in reverse order
    execute_shutdown_callbacks();
 
    // Step 2: Clear loggers from registry
    clear_loggers();
 
    // Step 3: Mark as not initialized
    initialized_ = false;
}
 
inline bool SystemBootstrapper::is_initialized() const noexcept {
    std::lock_guard<std::mutex> lock(state_mutex_);
    return initialized_;
}
 
inline void SystemBootstrapper::reset() {
    // Shutdown if initialized
    if (is_initialized()) {
        shutdown();
    }
 
    std::lock_guard<std::mutex> lock(state_mutex_);
 
    // Clear all configuration
    default_logger_factory_ = nullptr;
    named_logger_factories_.clear();
    init_callbacks_.clear();
    shutdown_callbacks_.clear();
    auto_freeze_logger_registry_ = false;
    auto_freeze_service_container_ = false;
}
 
inline VoidResult SystemBootstrapper::register_loggers() {
    auto& registry = interfaces::GlobalLoggerRegistry::instance();
 
    // Register default logger
    if (default_logger_factory_) {
        auto logger = default_logger_factory_();
        if (!logger) {
            return make_error<std::monostate>(
                error_codes::INTERNAL_ERROR,
                "Default logger factory returned null",
                "bootstrap::SystemBootstrapper"
            );
        }
        auto result = registry.set_default_logger(std::move(logger));
        if (result.is_err()) {
            return result;
        }
    }
 
    // Register named loggers
    for (const auto& [name, factory] : named_logger_factories_) {
        if (!factory) {
            continue;  // Skip null factories
        }
        auto logger = factory();
        if (!logger) {
            return make_error<std::monostate>(
                error_codes::INTERNAL_ERROR,
                "Logger factory for '" + name + "' returned null",
                "bootstrap::SystemBootstrapper"
            );
        }
        auto result = registry.register_logger(name, std::move(logger));
        if (result.is_err()) {
            // Clean up already registered loggers
            clear_loggers();
            return result;
        }
    }
 
    return VoidResult::ok({});
}
 
inline void SystemBootstrapper::execute_init_callbacks() {
    for (const auto& callback : init_callbacks_) {
        if (callback) {
            callback();
        }
    }
}
 
inline void SystemBootstrapper::execute_shutdown_callbacks() {
    // Execute in reverse order (LIFO)
    for (auto it = shutdown_callbacks_.rbegin();
         it != shutdown_callbacks_.rend();
         ++it) {
        if (*it) {
            (*it)();
        }
    }
}
 
inline void SystemBootstrapper::clear_loggers() {
    interfaces::GlobalLoggerRegistry::instance().clear();
}
 
} // namespace kcenon::common::bootstrap