unified_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 "service_container.h"
#include "../interfaces/logger_interface.h"
#include "../concepts/service.h"
#include "../config/feature_system_deps.h"
 
#include <atomic>
#include <chrono>
#include <csignal>
#include <functional>
#include <memory>
#include <mutex>
#include <string_view>
#include <vector>
 
namespace kcenon::common {
namespace di {
 
struct bootstrapper_options {
    bool enable_logging = true;
 
    bool enable_monitoring = true;
 
    bool enable_database = false;
 
    bool enable_network = false;
 
    std::string config_path;
 
    std::chrono::milliseconds shutdown_timeout{30000};
 
    bool register_signal_handlers = true;
};
 
using shutdown_hook = std::function<void(std::chrono::milliseconds remaining_timeout)>;
 
using module_registration_fn = std::function<VoidResult(IServiceContainer&)>;
 
class unified_bootstrapper {
public:
    // Prevent instantiation
    unified_bootstrapper() = delete;
    ~unified_bootstrapper() = delete;
    unified_bootstrapper(const unified_bootstrapper&) = delete;
    unified_bootstrapper& operator=(const unified_bootstrapper&) = delete;
 
    static VoidResult initialize(const bootstrapper_options& opts = {});
 
    static VoidResult shutdown(
        std::chrono::milliseconds timeout = std::chrono::seconds(30));
 
    static service_container& services();
 
    static bool is_initialized();
 
    static bool is_shutdown_requested();
 
    static VoidResult register_shutdown_hook(
        const std::string& name,
        shutdown_hook hook);
 
    static VoidResult unregister_shutdown_hook(const std::string& name);
 
    static void request_shutdown(bool trigger_shutdown = false);
 
    static bootstrapper_options get_options();
 
    // ===== Module Registration =====
 
    static VoidResult register_module(
        const std::string& name,
        module_registration_fn fn);
 
    template<typename M>
        requires concepts::ModuleRegistrar<M>
    static VoidResult register_module(M registrar);
 
    static VoidResult unregister_module(const std::string& name);
 
    static std::vector<std::string> registered_modules();
 
    static bool is_module_registered(const std::string& name);
 
private:
    static VoidResult register_core_services();
 
    static VoidResult register_optional_services(const bootstrapper_options& opts);
 
    static void setup_default_shutdown_hooks();
 
    static void setup_signal_handlers();
 
    static void signal_handler(int signal);
 
    static void execute_shutdown_hooks(std::chrono::milliseconds timeout);
 
    // State
    static std::atomic<bool> initialized_;
    static std::atomic<bool> shutdown_requested_;
    static std::mutex mutex_;
    static bootstrapper_options options_;
 
    // Shutdown hooks
    struct shutdown_hook_entry {
        std::string name;
        shutdown_hook hook;
    };
    static std::vector<shutdown_hook_entry> shutdown_hooks_;
 
    // Module registrations
    struct module_entry {
        std::string name;
        module_registration_fn registration_fn;
        bool services_registered = false;
    };
    static std::vector<module_entry> modules_;
};
 
// ============================================================================
// unified_bootstrapper Implementation
// ============================================================================
 
inline std::atomic<bool> unified_bootstrapper::initialized_{false};
inline std::atomic<bool> unified_bootstrapper::shutdown_requested_{false};
inline std::mutex unified_bootstrapper::mutex_;
inline bootstrapper_options unified_bootstrapper::options_;
inline std::vector<unified_bootstrapper::shutdown_hook_entry>
    unified_bootstrapper::shutdown_hooks_;
inline std::vector<unified_bootstrapper::module_entry>
    unified_bootstrapper::modules_;
 
inline VoidResult unified_bootstrapper::initialize(const bootstrapper_options& opts) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Check if already initialized
    if (initialized_.load()) {
        return VoidResult::ok({});
    }
 
    // Store options
    options_ = opts;
 
    // Register core services
    auto core_result = register_core_services();
    if (core_result.is_err()) {
        return core_result;
    }
 
    // Register optional services
    auto optional_result = register_optional_services(opts);
    if (optional_result.is_err()) {
        // Cleanup on failure
        service_container::global().clear();
        // Reset module registration flags so they can be retried
        for (auto& module : modules_) {
            module.services_registered = false;
        }
        return optional_result;
    }
 
    // Set up default shutdown hooks
    setup_default_shutdown_hooks();
 
    // Set up signal handlers
    if (opts.register_signal_handlers) {
        setup_signal_handlers();
    }
 
    // Mark as initialized
    initialized_.store(true);
    shutdown_requested_.store(false);
 
    return VoidResult::ok({});
}
 
inline VoidResult unified_bootstrapper::shutdown(std::chrono::milliseconds timeout) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!initialized_.load()) {
        return make_error<std::monostate>(
            error_codes::NOT_INITIALIZED,
            "System is not initialized",
            "di::unified_bootstrapper"
        );
    }
 
    // Mark shutdown as requested
    shutdown_requested_.store(true);
 
    // Execute shutdown hooks
    execute_shutdown_hooks(timeout);
 
    // Clear all services
    service_container::global().clear();
 
    // Clear shutdown hooks and modules
    shutdown_hooks_.clear();
    modules_.clear();
 
    // Reset state
    initialized_.store(false);
    shutdown_requested_.store(false);
    options_ = bootstrapper_options{};
 
    return VoidResult::ok({});
}
 
inline service_container& unified_bootstrapper::services() {
    if (!initialized_.load()) {
        throw std::runtime_error(
            "unified_bootstrapper: System is not initialized. "
            "Call initialize() first."
        );
    }
    return service_container::global();
}
 
inline bool unified_bootstrapper::is_initialized() {
    return initialized_.load();
}
 
inline bool unified_bootstrapper::is_shutdown_requested() {
    return shutdown_requested_.load();
}
 
inline VoidResult unified_bootstrapper::register_shutdown_hook(
    const std::string& name,
    shutdown_hook hook) {
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (!initialized_.load()) {
        return make_error<std::monostate>(
            error_codes::NOT_INITIALIZED,
            "System is not initialized",
            "di::unified_bootstrapper"
        );
    }
 
    // Check for duplicate
    for (const auto& entry : shutdown_hooks_) {
        if (entry.name == name) {
            return make_error<std::monostate>(
                error_codes::ALREADY_EXISTS,
                "Shutdown hook already registered: " + name,
                "di::unified_bootstrapper"
            );
        }
    }
 
    shutdown_hooks_.push_back({name, std::move(hook)});
    return VoidResult::ok({});
}
 
inline VoidResult unified_bootstrapper::unregister_shutdown_hook(
    const std::string& name) {
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    auto it = std::find_if(shutdown_hooks_.begin(), shutdown_hooks_.end(),
        [&name](const shutdown_hook_entry& entry) {
            return entry.name == name;
        });
 
    if (it == shutdown_hooks_.end()) {
        return make_error<std::monostate>(
            error_codes::NOT_FOUND,
            "Shutdown hook not found: " + name,
            "di::unified_bootstrapper"
        );
    }
 
    shutdown_hooks_.erase(it);
    return VoidResult::ok({});
}
 
inline void unified_bootstrapper::request_shutdown(bool trigger_shutdown) {
    shutdown_requested_.store(true);
 
    if (trigger_shutdown) {
        shutdown(options_.shutdown_timeout);
    }
}
 
inline bootstrapper_options unified_bootstrapper::get_options() {
    std::lock_guard<std::mutex> lock(mutex_);
    return options_;
}
 
// ============================================================================
// Module Registration Implementation
// ============================================================================
 
inline VoidResult unified_bootstrapper::register_module(
    const std::string& name,
    module_registration_fn fn) {
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    // Check for duplicate
    for (const auto& entry : modules_) {
        if (entry.name == name) {
            return make_error<std::monostate>(
                error_codes::ALREADY_EXISTS,
                "Module already registered: " + name,
                "di::unified_bootstrapper"
            );
        }
    }
 
    // If already initialized, register services immediately
    if (initialized_.load()) {
        auto& container = service_container::global();
        auto result = fn(container);
        if (!result.is_ok()) {
            return result;
        }
        modules_.push_back({name, std::move(fn), true});
    } else {
        // Store for deferred registration during initialize()
        modules_.push_back({name, std::move(fn), false});
    }
 
    return VoidResult::ok({});
}
 
template<typename M>
    requires concepts::ModuleRegistrar<M>
VoidResult unified_bootstrapper::register_module(M registrar) {
    return register_module(
        std::string(M::module_name()),
        [r = std::move(registrar)](IServiceContainer& container) mutable {
            return r.register_services(container);
        }
    );
}
 
inline VoidResult unified_bootstrapper::unregister_module(const std::string& name) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    auto it = std::find_if(modules_.begin(), modules_.end(),
        [&name](const module_entry& entry) {
            return entry.name == name;
        });
 
    if (it == modules_.end()) {
        return make_error<std::monostate>(
            error_codes::NOT_FOUND,
            "Module not found: " + name,
            "di::unified_bootstrapper"
        );
    }
 
    modules_.erase(it);
    return VoidResult::ok({});
}
 
inline std::vector<std::string> unified_bootstrapper::registered_modules() {
    std::lock_guard<std::mutex> lock(mutex_);
 
    std::vector<std::string> names;
    names.reserve(modules_.size());
    for (const auto& entry : modules_) {
        names.push_back(entry.name);
    }
    return names;
}
 
inline bool unified_bootstrapper::is_module_registered(const std::string& name) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    return std::find_if(modules_.begin(), modules_.end(),
        [&name](const module_entry& entry) {
            return entry.name == name;
        }) != modules_.end();
}
 
inline VoidResult unified_bootstrapper::register_core_services() {
    // Core services are minimal and always registered
    // The service_container itself is already available via services()
    // No additional core services are required at this time
    //
    // Future core services that might be registered here:
    // - Default error handlers
    // - Core diagnostics
    // - System-level configuration providers
    //
    // For now, just ensure the container is initialized
    // Subsystems register their own services via their adapter modules
 
    return VoidResult::ok({});
}
 
inline VoidResult unified_bootstrapper::register_optional_services(
    const bootstrapper_options& opts) {
 
    // Optional services are registered based on configuration
    // Each subsystem provides registration functions via adapters
    // The registration is conditional based on:
    // 1. bootstrapper_options flags (enable_logging, etc.)
    // 2. Feature detection macros (KCENON_WITH_*_SYSTEM)
    // 3. Dynamically registered modules via register_module()
 
    auto& container = service_container::global();
 
    // --- Compile-time subsystem integration (legacy) ---
 
    // Logging services
    if (opts.enable_logging) {
#if KCENON_WITH_LOGGER_SYSTEM
        // When logger_system is available and registered via register_module(),
        // it will be handled below. The #ifdef path is kept for backward
        // compatibility until all subsystems migrate to register_module().
#endif
    }
 
    // Monitoring services
    if (opts.enable_monitoring) {
#if KCENON_WITH_MONITORING_SYSTEM
        // Same as above - handled by register_module() when available.
#endif
    }
 
    // Database services
    if (opts.enable_database) {
#if KCENON_WITH_DATABASE_SYSTEM
        // Same as above - handled by register_module() when available.
#endif
    }
 
    // Network services
    if (opts.enable_network) {
#if KCENON_WITH_NETWORK_SYSTEM
        // Same as above - handled by register_module() when available.
#endif
    }
 
    // --- Dynamic module registration ---
    // Call registration functions for all modules registered before initialize()
    for (auto& module : modules_) {
        if (!module.services_registered) {
            auto result = module.registration_fn(container);
            if (!result.is_ok()) {
                return make_error<std::monostate>(
                    result.error().code,
                    "Module '" + module.name + "' registration failed: "
                        + result.error().message,
                    "di::unified_bootstrapper"
                );
            }
            module.services_registered = true;
        }
    }
 
    return VoidResult::ok({});
}
 
inline void unified_bootstrapper::setup_default_shutdown_hooks() {
    // Register default shutdown hooks for core cleanup
 
    // Service container cleanup hook (runs last, lowest priority)
    shutdown_hooks_.push_back({
        "service_container_cleanup",
        [](std::chrono::milliseconds) {
            // Container cleanup is handled by shutdown() itself
        }
    });
}
 
inline void unified_bootstrapper::setup_signal_handlers() {
#ifndef _WIN32
    // POSIX signal handling
    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
 
    sigaction(SIGTERM, &sa, nullptr);
    sigaction(SIGINT, &sa, nullptr);
#else
    // Windows signal handling
    std::signal(SIGTERM, signal_handler);
    std::signal(SIGINT, signal_handler);
#endif
}
 
inline void unified_bootstrapper::signal_handler(int signal) {
    (void)signal;  // Unused parameter
 
    // Request shutdown but don't trigger it from signal handler
    // The main thread should check is_shutdown_requested() and call shutdown()
    shutdown_requested_.store(true);
}
 
inline void unified_bootstrapper::execute_shutdown_hooks(
    std::chrono::milliseconds timeout) {
 
    auto start = std::chrono::steady_clock::now();
 
    // Execute hooks in reverse order (LIFO)
    for (auto it = shutdown_hooks_.rbegin(); it != shutdown_hooks_.rend(); ++it) {
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::steady_clock::now() - start);
        auto remaining = timeout - elapsed;
 
        if (remaining <= std::chrono::milliseconds::zero()) {
            // Timeout reached, skip remaining hooks
            break;
        }
 
        try {
            it->hook(remaining);
        } catch (...) {
            // Ignore exceptions during shutdown
        }
    }
}
 
} // namespace di
} // namespace kcenon::common