database::integrated::database_coordinator::impl Class Reference

Collaboration diagram for database::integrated::database_coordinator::impl:

Public Member Functions
	impl (const unified_db_config &config)
	~impl ()
common::VoidResult	initialize ()
common::VoidResult	shutdown ()
bool	is_initialized () const
adapters::logger_adapter *	get_logger ()
adapters::monitoring_adapter *	get_monitor ()
adapters::thread_adapter *	get_thread_pool ()
common::Result< bool >	check_health ()
common::Result< database_coordinator::coordinator_stats >	get_stats () const

Private Attributes
unified_db_config	config_
bool	initialized_
std::unique_ptr< adapters::logger_adapter >	logger_
std::unique_ptr< adapters::monitoring_adapter >	monitor_
std::unique_ptr< adapters::thread_adapter >	thread_pool_
std::chrono::system_clock::time_point	init_time_

Detailed Description

Definition at line 32 of file database_coordinator.cpp.

Constructor & Destructor Documentation

impl()

database::integrated::database_coordinator::impl::impl ( const unified_db_config & config )

inlineexplicit

Definition at line 35 of file database_coordinator.cpp.

        : config_(config)
        , initialized_(false)
        , logger_(nullptr)
        , monitor_(nullptr)
        , thread_pool_(nullptr)
        , init_time_()
    {
    }

~impl()

database::integrated::database_coordinator::impl::~impl ( )

inline

Definition at line 45 of file database_coordinator.cpp.

    {
        if (initialized_)
        {
            shutdown();
        }
    }

References initialized_, and shutdown().

Here is the call graph for this function:

Member Function Documentation

check_health()

common::Result< bool > database::integrated::database_coordinator::impl::check_health ( )

inline

Definition at line 300 of file database_coordinator.cpp.

    {
        if (!initialized_)
        {
            return common::Result<bool>(
                common::error_info{ -1, "Coordinator not initialized", "" }
            );
        }
 
        bool overall_healthy = true;
 
        // Check logger
        if (!logger_)
        {
            overall_healthy = false;
        }
 
        // Check monitoring
        if (!monitor_)
        {
            overall_healthy = false;
        }
        else
        {
            auto monitor_health = monitor_->check_health();
            if (!monitor_health.is_ok())
            {
                overall_healthy = false;
                if (logger_)
                {
                    logger_->log(db_log_level::warning, "Monitoring health check failed");
                }
            }
        }
 
        // Check thread pool
        if (!thread_pool_)
        {
            overall_healthy = false;
        }
        // Thread pool is healthy if it exists
        // (No statistics method available in thread_adapter yet)
 
        return common::Result<bool>(overall_healthy);
    }

References initialized_, logger_, monitor_, thread_pool_, and database::integrated::warning.

get_logger()

adapters::logger_adapter * database::integrated::database_coordinator::impl::get_logger ( )

inline

Definition at line 285 of file database_coordinator.cpp.

    {
        return logger_.get();
    }

References logger_.

get_monitor()

adapters::monitoring_adapter * database::integrated::database_coordinator::impl::get_monitor ( )

inline

Definition at line 290 of file database_coordinator.cpp.

    {
        return monitor_.get();
    }

References monitor_.

get_stats()

common::Result< database_coordinator::coordinator_stats > database::integrated::database_coordinator::impl::get_stats ( ) const

inline

Definition at line 346 of file database_coordinator.cpp.

    {
        coordinator_stats stats;
        stats.is_initialized = initialized_;
        stats.logger_healthy = (logger_ != nullptr);
        stats.monitoring_healthy = (monitor_ != nullptr);
        stats.thread_pool_healthy = (thread_pool_ != nullptr);
        stats.init_time = init_time_;
 
        if (initialized_)
        {
            auto now = std::chrono::system_clock::now();
            stats.uptime
                = std::chrono::duration_cast<std::chrono::milliseconds>(now - init_time_);
        }
        else
        {
            stats.uptime = std::chrono::milliseconds(0);
        }
 
        return common::Result<coordinator_stats>(stats);
    }

References database::integrated::database_coordinator::coordinator_stats::init_time, init_time_, initialized_, database::integrated::database_coordinator::coordinator_stats::is_initialized, logger_, database::integrated::database_coordinator::coordinator_stats::logger_healthy, monitor_, database::integrated::database_coordinator::coordinator_stats::monitoring_healthy, thread_pool_, database::integrated::database_coordinator::coordinator_stats::thread_pool_healthy, and database::integrated::database_coordinator::coordinator_stats::uptime.

get_thread_pool()

adapters::thread_adapter * database::integrated::database_coordinator::impl::get_thread_pool ( )

inline

Definition at line 295 of file database_coordinator.cpp.

    {
        return thread_pool_.get();
    }

References thread_pool_.

initialize()

common::VoidResult database::integrated::database_coordinator::impl::initialize ( )

inline

Definition at line 53 of file database_coordinator.cpp.

    {
        if (initialized_)
        {
            return make_error("Coordinator already initialized");
        }
 
        init_time_ = std::chrono::system_clock::now();
 
        try
        {
            // ═══════════════════════════════════════════════════════════════
            // Phase 1: Initialize Logger (for observability of other inits)
            // ═══════════════════════════════════════════════════════════════
            logger_ = std::make_unique<adapters::logger_adapter>(config_.logger);
 
            auto logger_result = logger_->initialize();
            if (!logger_result.is_ok())
            {
                logger_.reset();
                return make_error(
                    "Logger initialization failed: "
#if defined(USE_COMMON_SYSTEM)
                        + logger_result.error().message
#else
                        + logger_result.error().message
#endif
                );
            }
 
            logger_->log(db_log_level::info, "Database coordinator: Logger initialized");
 
            // ═══════════════════════════════════════════════════════════════
            // Phase 2: Initialize Monitoring (for metrics collection)
            // ═══════════════════════════════════════════════════════════════
            monitor_ = std::make_unique<adapters::monitoring_adapter>(config_.monitoring);
 
            auto monitor_result = monitor_->initialize();
            if (!monitor_result.is_ok())
            {
                logger_->log(db_log_level::error, "Monitoring initialization failed");
 
                // Rollback: shutdown logger
                logger_->shutdown();
                logger_.reset();
                monitor_.reset();
 
                return make_error(
                    "Monitoring initialization failed: "
#if defined(USE_COMMON_SYSTEM)
                        + monitor_result.error().message
#else
                        + monitor_result.error().message
#endif
                );
            }
 
            logger_->log(db_log_level::info, "Database coordinator: Monitoring initialized");
 
            // ═══════════════════════════════════════════════════════════════
            // Phase 3: Initialize Thread Pool (for async operations)
            // ═══════════════════════════════════════════════════════════════
            thread_pool_ = std::make_unique<adapters::thread_adapter>(config_.thread);
 
            auto thread_result = thread_pool_->initialize();
            if (!thread_result.is_ok())
            {
                logger_->log(db_log_level::error, "Thread pool initialization failed");
 
                // Rollback: shutdown monitor and logger
                monitor_->shutdown();
                monitor_.reset();
                logger_->shutdown();
                logger_.reset();
                thread_pool_.reset();
 
                return make_error(
                    "Thread pool initialization failed: "
#if defined(USE_COMMON_SYSTEM)
                        + thread_result.error().message
#else
                        + thread_result.error().message
#endif
                );
            }
 
            logger_->log(db_log_level::info, "Database coordinator: Thread pool initialized");
 
            // ═══════════════════════════════════════════════════════════════
            // Initialization Complete
            // ═══════════════════════════════════════════════════════════════
            initialized_ = true;
 
            logger_->log(db_log_level::info,
                         "Database coordinator: All adapters initialized successfully");
 
            return common::ok();
        }
        catch (const std::exception& e)
        {
            // Clean up any partially initialized adapters
            if (thread_pool_)
            {
                thread_pool_->shutdown();
                thread_pool_.reset();
            }
            if (monitor_)
            {
                monitor_->shutdown();
                monitor_.reset();
            }
            if (logger_)
            {
                logger_->log(db_log_level::error,
                             std::string("Exception during initialization: ") + e.what());
                logger_->shutdown();
                logger_.reset();
            }
 
            return make_error(std::string("Exception during initialization: ") + e.what());
        }
    }

References config_, database::integrated::error, database::integrated::info, init_time_, initialized_, database::integrated::unified_db_config::logger, logger_, monitor_, database::integrated::unified_db_config::monitoring, common::ok(), database::integrated::unified_db_config::thread, and thread_pool_.

Here is the call graph for this function:

is_initialized()

bool database::integrated::database_coordinator::impl::is_initialized ( ) const

inline

Definition at line 280 of file database_coordinator.cpp.

    {
        return initialized_;
    }

References initialized_.

shutdown()

common::VoidResult database::integrated::database_coordinator::impl::shutdown ( )

inline

Definition at line 176 of file database_coordinator.cpp.

    {
        if (!initialized_)
        {
            return common::ok(); // Already shut down
        }
 
        try
        {
            // Shutdown in REVERSE order of initialization
            // This ensures dependencies are torn down safely
 
            // ═══════════════════════════════════════════════════════════════
            // Phase 1: Shutdown Thread Pool
            // ═══════════════════════════════════════════════════════════════
            if (thread_pool_)
            {
                if (logger_)
                {
                    logger_->log(db_log_level::info,
                                 "Database coordinator: Shutting down thread pool");
                }
 
                auto thread_result = thread_pool_->shutdown();
                if (!thread_result.is_ok())
                {
                    if (logger_)
                    {
                        logger_->log(db_log_level::warning,
                                     "Thread pool shutdown warning: "
#if defined(USE_COMMON_SYSTEM)
                                         + thread_result.error().message
#else
                                         + thread_result.error().message
#endif
                        );
                    }
                }
 
                thread_pool_.reset();
            }
 
            // ═══════════════════════════════════════════════════════════════
            // Phase 2: Shutdown Monitoring
            // ═══════════════════════════════════════════════════════════════
            if (monitor_)
            {
                if (logger_)
                {
                    logger_->log(db_log_level::info,
                                 "Database coordinator: Shutting down monitoring");
                }
 
                auto monitor_result = monitor_->shutdown();
                if (!monitor_result.is_ok())
                {
                    if (logger_)
                    {
                        logger_->log(db_log_level::warning,
                                     "Monitoring shutdown warning: "
#if defined(USE_COMMON_SYSTEM)
                                         + monitor_result.error().message
#else
                                         + monitor_result.error().message
#endif
                        );
                    }
                }
 
                monitor_.reset();
            }
 
            // ═══════════════════════════════════════════════════════════════
            // Phase 3: Shutdown Logger (LAST - keep logging until the end)
            // ═══════════════════════════════════════════════════════════════
            if (logger_)
            {
                logger_->log(db_log_level::info,
                             "Database coordinator: Shutdown complete");
                logger_->flush(); // Ensure all logs are written
 
                auto logger_result = logger_->shutdown();
                // Don't log logger shutdown errors (logger is shutting down!)
 
                logger_.reset();
            }
 
            initialized_ = false;
 
            return common::ok();
        }
        catch (const std::exception& e)
        {
            // Best effort cleanup
            thread_pool_.reset();
            monitor_.reset();
            logger_.reset();
 
            initialized_ = false;
 
            return make_error(std::string("Exception during shutdown: ") + e.what());
        }
    }

References database::integrated::info, initialized_, logger_, monitor_, common::ok(), thread_pool_, and database::integrated::warning.

Referenced by ~impl().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

config_

unified_db_config database::integrated::database_coordinator::impl::config_

private

Definition at line 370 of file database_coordinator.cpp.

Referenced by initialize().

init_time_

std::chrono::system_clock::time_point database::integrated::database_coordinator::impl::init_time_

private

Definition at line 379 of file database_coordinator.cpp.

Referenced by get_stats(), and initialize().

initialized_

bool database::integrated::database_coordinator::impl::initialized_

private

Definition at line 371 of file database_coordinator.cpp.

Referenced by check_health(), get_stats(), initialize(), is_initialized(), shutdown(), and ~impl().

logger_

std::unique_ptr<adapters::logger_adapter> database::integrated::database_coordinator::impl::logger_

private

Definition at line 374 of file database_coordinator.cpp.

Referenced by check_health(), get_logger(), get_stats(), initialize(), and shutdown().

monitor_

std::unique_ptr<adapters::monitoring_adapter> database::integrated::database_coordinator::impl::monitor_

private

Definition at line 375 of file database_coordinator.cpp.

Referenced by check_health(), get_monitor(), get_stats(), initialize(), and shutdown().

thread_pool_

std::unique_ptr<adapters::thread_adapter> database::integrated::database_coordinator::impl::thread_pool_

private

Definition at line 376 of file database_coordinator.cpp.

Referenced by check_health(), get_stats(), get_thread_pool(), initialize(), and shutdown().

---

The documentation for this class was generated from the following file:

• database/integrated/core/database_coordinator.cpp