#include <Server.hpp>

Inheritance diagram for DatabaseProcess:

Collaboration diagram for DatabaseProcess:

Public Member Functions
	DatabaseProcess ()

	DatabaseProcess (Kernel *kernel)

	~DatabaseProcess ()

void	initialize (int segment_number=1) override

void	reinitialize ()

void	initialize (boost::asio::io_context &io_context, int segment_number, std::string host, int port, std::string user, std::string pass, std::string database)

void	finalize () override

std::shared_ptr< boost::mysql::tcp_ssl_connection >	get_connection ()

bool	is_initialized () override

bool	is_finalized () override

Public Member Functions inherited from KernelComponent
	KernelComponent (Kernel *kernel, Horizon::System::runtime_module_type module_type)

virtual void	initialize (int segment_number=1)

virtual void	finalize ()

virtual bool	is_initialized ()

virtual bool	is_finalized ()

void	set_segment_number (int64_t segment_number)

int64_t	get_segment_number ()

void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContext > context)

void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContextChain > context)

void	system_routine_process_queue ()

void	system_routine_register (Horizon::System::runtime_module_type module_t, Horizon::System::runtime_synchronization_method sync_t, std::shared_ptr< Horizon::System::RuntimeContext > context)

const std::string	get_uuid_string ()

const std::string	get_type_string ()

Horizon::System::SystemRoutineManager &	get_system_routine_manager ()

Kernel *	get_kernel ()

void	set_thread_cpu_id (int cpu_id)

int	get_thread_cpu_id ()

void	set_thread_update_rate (double rate)

double	get_thread_update_rate ()

void	set_total_execution_time (int time)

int	get_total_execution_time ()

void	calculate_and_set_cpu_load ()

Protected Attributes
boost::asio::io_context *	_io_context

std::shared_ptr< boost::asio::ssl::context >	_ssl_ctx {nullptr}

std::shared_ptr< boost::mysql::tcp_ssl_connection >	_connection {nullptr}

std::string	_host

int	_port

std::string	_user

std::string	_pass

std::string	_database

std::atomic< bool >	_is_initialized {false}

std::atomic< bool >	_is_finalized {false}

Constructor & Destructor Documentation

◆ DatabaseProcess() [1/2]

DatabaseProcess::DatabaseProcess ( )

inline

373: KernelComponent(nullptr, Horizon::System::RUNTIME_DATABASE) { }

KernelComponent::KernelComponent

KernelComponent(Kernel *kernel, Horizon::System::runtime_module_type module_type)

Definition: Server.hpp:194

Horizon::System::RUNTIME_DATABASE

@ RUNTIME_DATABASE

Definition: System.hpp:88

◆ DatabaseProcess() [2/2]

DatabaseProcess::DatabaseProcess ( Kernel * kernel )

inline

375: KernelComponent(kernel, Horizon::System::RUNTIME_DATABASE) { }

◆ ~DatabaseProcess()

DatabaseProcess::~DatabaseProcess ( )

inline

    { 
        _connection.reset();
        _ssl_ctx.reset();
    }

References _connection, and _ssl_ctx.

Member Function Documentation

◆ finalize()

void DatabaseProcess::finalize ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

    {
        // Close connection object.
        if (_connection != nullptr) {
            _connection->close();
        }
        
        _is_finalized.exchange(true);
    }

References _connection, and _is_finalized.

◆ get_connection()

std::shared_ptr< boost::mysql::tcp_ssl_connection > DatabaseProcess::get_connection ( )

                                                                            { 
    try {
        boost::mysql::results results;
        _connection->execute("SELECT 'Hello World!'", results);
    } catch (const boost::mysql::error_with_diagnostics &e) {
        HLog(error) << "Database connection error: " << e.what();
        HLog(error) << "Reconnecting...";
        reinitialize();
    }
    return _connection; 
}

References _connection, HLog, and reinitialize().

Here is the call graph for this function:

◆ initialize() [1/2]

void DatabaseProcess::initialize	(	boost::asio::io_context &	io_context,
		int	segment_number,
		std::string	host,
		int	port,
		std::string	user,
		std::string	pass,
		std::string	database
	)

{
    set_segment_number(segment_number);
    
    try {
        _io_context = &io_context;
        _ssl_ctx = std::make_shared<boost::asio::ssl::context>(boost::asio::ssl::context::tls_client);
        _connection = std::make_shared<boost::mysql::tcp_ssl_connection>(_io_context->get_executor(), *_ssl_ctx);
        boost::asio::ip::tcp::resolver resolver(_io_context->get_executor());
        auto endpoints = resolver.resolve(host, std::to_string(port));
        boost::mysql::handshake_params params(user, pass, database);
        _connection->connect(*endpoints.begin(), params);
        _is_initialized.exchange(true);
        _host = host;
        _port = port;
        _user = user;
        _pass = pass;
        _database = database;
#if WIN32
        DWORD cpu = GetCurrentProcessorNumber();
        if (get_thread_cpu_id() != (int) cpu) 
            set_thread_cpu_id(cpu);
#elif __linux__
        int cpu = sched_getcpu();
        if (get_thread_cpu_id() != cpu)
            set_thread_cpu_id(cpu);
#endif
        calculate_and_set_cpu_load();
    } catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << error.what();
    }
}

References _connection, _database, _host, _io_context, _is_initialized, _pass, _port, _ssl_ctx, _user, KernelComponent::calculate_and_set_cpu_load(), KernelComponent::get_thread_cpu_id(), HLog, KernelComponent::set_segment_number(), and KernelComponent::set_thread_cpu_id().

Here is the call graph for this function:

◆ initialize() [2/2]

void DatabaseProcess::initialize ( int segment_number = 1 )

inlineoverridevirtual

Reimplemented from KernelComponent.

    {
        set_segment_number(segment_number);
        HLog(error) << "Database not configured"; 
        _is_initialized.exchange(true);
    }

References _is_initialized, HLog, and KernelComponent::set_segment_number().

Referenced by BOOST_AUTO_TEST_CASE(), and reinitialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_finalized()

bool DatabaseProcess::is_finalized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

414{ return _is_finalized.load(); }

References _is_finalized.

◆ is_initialized()

bool DatabaseProcess::is_initialized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

413{ return _is_initialized.load(); }

References _is_initialized.

◆ reinitialize()

void DatabaseProcess::reinitialize ( )

inline

    {
        _connection.reset();
        _ssl_ctx.reset();
        _is_initialized.exchange(false);
        _is_finalized.exchange(false);
        if (_io_context != nullptr) 
            initialize(*_io_context, get_segment_number(), _host, _port, _user, _pass, _database);
    }