CommandLineProcess Class Reference

#include <Server.hpp>

Inheritance diagram for CommandLineProcess:

Collaboration diagram for CommandLineProcess:

Public Member Functions
	CommandLineProcess (Kernel *kernel)
void	process ()
void	queue (CLICommand &&cmdMgr)
void	add_function (std::string cmd, std::function< bool(std::string)> func)
std::function< bool(std::string)>	find (std::string &cmd)
void	initialize (int segment_number=1) override
void	finalize () override
void	command_complete (CLICommand, bool)
void	cli_thread_start ()
bool	clicmd_shutdown (std::string)
	CLI Commands. More...
bool	clicmd_kernel_info (std::string)
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 ()

Private Attributes
std::unordered_map< std::string, std::function< bool(std::string)> >	_cli_function_map
std::queue< CLICommand >	_cli_cmd_queue
std::thread	_cli_thread
std::atomic< bool >	_is_initialized {false}
std::atomic< bool >	_is_finalized {false}
std::atomic< bool >	_is_running_command {false}

Constructor & Destructor Documentation

CommandLineProcess()

CommandLineProcess::CommandLineProcess ( Kernel *  kernel )

inline

: KernelComponent(kernel, Horizon::System::RUNTIME_COMMANDLINE) { }

Member Function Documentation

add_function()

void CommandLineProcess::add_function ( std::string  cmd, std::function< bool(std::string)>  func  )

inline

{ _cli_function_map.insert(std::make_pair(cmd, func)); };

References _cli_function_map.

Referenced by initialize().

Here is the caller graph for this function:

cli_thread_start()

void CommandLineProcess::cli_thread_start

(

)

{
    while (get_shutdown_stage() == SHUTDOWN_NOT_STARTED)
    {
        std::string command;
 
        process();
#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();
 
        try {
            while(_is_running_command.load() == true)
            {
                std::this_thread::sleep_for(std::chrono::seconds(1));
            };
            std::cout << TERMINAL_STR;
            std::getline(std::cin, command);
            std::flush(std::cout);
            if (command.size()) {
                std::vector<std::string> separated_args;
                boost::algorithm::split(separated_args, command, boost::algorithm::is_any_of(" "));
 
                if (find(separated_args[0]) == nullptr)
                    HLog(error) << "Command '" << separated_args[0] << "' not found.";
                else
                    _is_running_command.exchange(true);
            }
        } catch(std::bad_alloc &e) {
            HLog(error) << "Failed to allocate memory for command line input.";
            set_shutdown_stage(SHUTDOWN_INITIATED);
            set_shutdown_signal(SIGTERM);
            break;
        } catch(std::length_error &e) {
            HLog(error) << "Command line input too long.";
            set_shutdown_stage(SHUTDOWN_INITIATED);
            set_shutdown_signal(SIGTERM);
            break;
        }
 
        if (command.size()) {
            queue(CLICommand((char *)command.c_str(), std::bind(&CommandLineProcess::command_complete, this, std::placeholders::_1, std::placeholders::_2)));   
            std::this_thread::sleep_for(std::chrono::microseconds(MAX_CORE_UPDATE_INTERVAL * 1)); // Sleep until core has updated.
        } else if (feof(stdin)) {
            set_shutdown_stage(SHUTDOWN_INITIATED);
            set_shutdown_signal(SIGTERM);
        }
    }
}

References _is_running_command, KernelComponent::calculate_and_set_cpu_load(), command_complete(), find(), get_shutdown_stage(), KernelComponent::get_thread_cpu_id(), HLog, MAX_CORE_UPDATE_INTERVAL, process(), queue(), set_shutdown_signal(), set_shutdown_stage(), KernelComponent::set_thread_cpu_id(), SHUTDOWN_INITIATED, SHUTDOWN_NOT_STARTED, and TERMINAL_STR.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

clicmd_kernel_info()

bool CommandLineProcess::clicmd_kernel_info

(

std::string

)

{
    std::string red = "\033[31m";
    std::string green = "\033[32m";
    std::string reset = "\033[0m";
 
    get_kernel()->set_signal_interrupt_command_line_loop(true);
    HLog(info) << "Horizon Kernel (C) 2024 Initialized with " << get_kernel()->get_components().size() << " components.";
 
    while (get_kernel()->get_signal_interrupt_command_line_loop() == true) {
        int total_execution_time = 0.0;
 
        std::cout << "[Status]"
            << std::setw(15) << "Component (Segment #)"
            << std::setw(15) << "CPU #"
            << std::setw(15) << "Execution Time"
            << std::setw(15) << "Update Rate"
            << std::flush << std::endl;
        for (auto i = get_kernel()->get_components().begin(); i != get_kernel()->get_components().end(); i++) {
            std::string online = std::string(red + "Offline" + reset);
            if (i->second.ptr->is_initialized() == true)
                online = std::string(green + "Online" + reset);
            std::cout << "\r\033[K" << std::flush;
            
            double limited_update_rate = std::round(i->second.ptr->get_thread_update_rate() * 100.0) / 100.0;
 
            total_execution_time += i->second.ptr->get_total_execution_time();
            std::cout << "[" << online << "]"
                << std::setw(15) << i->second.ptr->get_type_string() << " (" << i->second.segment_number << ")"
                << std::setw(15) << i->second.ptr->get_thread_cpu_id()
                << std::setw(15) << i->second.ptr->get_total_execution_time() << "ns"
                << std::setw(15) << limited_update_rate << "/s." 
                << std::flush << std::endl;
        }
 
        std::cout << "Total Execution Time: " << total_execution_time << "ns" << std::endl;
        
        std::cout << "\033[" << get_kernel()->get_components().size() + 2 << "A";
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "\033[ " << get_kernel()->get_components().size() + 2 << "B";
    return true;
}

References Kernel::get_components(), KernelComponent::get_kernel(), HLog, and Kernel::set_signal_interrupt_command_line_loop().

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

clicmd_shutdown()

bool CommandLineProcess::clicmd_shutdown

(

std::string

)

CLI Commands.

{
    set_shutdown_stage(SHUTDOWN_INITIATED);
    set_shutdown_signal(SIGTERM);
    return true;
}

References set_shutdown_signal(), set_shutdown_stage(), and SHUTDOWN_INITIATED.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

command_complete()

void CommandLineProcess::command_complete ( CLICommand  , bool    )

inline

    {
        fflush(stdout);
    }

Referenced by cli_thread_start().

Here is the caller graph for this function:

finalize()

void CommandLineProcess::finalize ( )

overridevirtual

Reimplemented from KernelComponent.

{
    if (_cli_thread.joinable())
        _cli_thread.detach();
 
    _is_finalized.exchange(true);
}

References _cli_thread, and _is_finalized.

find()

std::function< bool(std::string)> CommandLineProcess::find ( std::string &  cmd )

inline

    {
        auto it = _cli_function_map.find(cmd);
        return (it != _cli_function_map.end()) ? it->second : nullptr;
    }

References _cli_function_map.

Referenced by cli_thread_start(), and process().

Here is the caller graph for this function:

initialize()

void CommandLineProcess::initialize ( int  segment_number = 1 )

overridevirtual

Reimplemented from KernelComponent.

{
 
    _cli_thread = std::thread(std::bind(&CommandLineProcess::cli_thread_start, this));
 
    add_function("shutdown", std::bind(&CommandLineProcess::clicmd_shutdown, this, std::placeholders::_1));
    add_function("kernel-info", std::bind(&CommandLineProcess::clicmd_kernel_info, this, std::placeholders::_1));
    set_segment_number(segment_number);
 
    _is_initialized.exchange(true);
}

References _cli_thread, _is_initialized, add_function(), cli_thread_start(), clicmd_kernel_info(), clicmd_shutdown(), and KernelComponent::set_segment_number().

Here is the call graph for this function:

is_finalized()

bool CommandLineProcess::is_finalized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

{ return _is_finalized; }

References _is_finalized.

is_initialized()

bool CommandLineProcess::is_initialized ( )

inlineoverridevirtual

Reimplemented from KernelComponent.

{ return _is_initialized; }

References _is_initialized.

process()

void CommandLineProcess::process

(

)

Error on this line, need to fix it. Particularly with VS Code debugger. It is probably only in the debugger because it acts wierd with line inputs. We will disable the command line on test runs for now. Exception thrown at 0x00007FFA60FAF39C in ZoneSystemTest.exe: Microsoft C++ exception: std::bad_alloc at memory location 0x000000851FAFE830. Failed to process command line input: bad allocation

{
    while (_cli_cmd_queue.size()) {
        try {
            CLICommand command = _cli_cmd_queue.front();
            _cli_cmd_queue.pop();
 
            bool ret = false;
            std::vector<std::string> separated_args;
            boost::algorithm::split(separated_args, command.m_command, boost::algorithm::is_any_of(" "));
        
            std::function<bool(std::string)> cmd_func = find(separated_args[0]);
        
            if (cmd_func) {
                ret = cmd_func(command.m_command);
                _is_running_command.exchange(false);
            }
        
            if (command.m_finish_func != nullptr)
                command.m_finish_func(command, ret);
        } catch(std::exception &e) {
            HLog(error) << "Failed to process command line input: " << e.what();
            return;
        }
    }
}

References _cli_cmd_queue, _is_running_command, find(), HLog, CLICommand::m_command, and CLICommand::m_finish_func.

Referenced by cli_thread_start().

Here is the call graph for this function:

Here is the caller graph for this function:

queue()

void CommandLineProcess::queue ( CLICommand &&  cmdMgr )

inline

{ _cli_cmd_queue.push(std::move(cmdMgr)); }

References _cli_cmd_queue.

Referenced by cli_thread_start().

Here is the caller graph for this function:

Member Data Documentation

_cli_cmd_queue

std::queue<CLICommand> CommandLineProcess::_cli_cmd_queue

private

Referenced by process(), and queue().

_cli_function_map

std::unordered_map<std::string, std::function<bool(std::string)> > CommandLineProcess::_cli_function_map

private

Referenced by add_function(), and find().

_cli_thread

std::thread CommandLineProcess::_cli_thread

private

Referenced by finalize(), and initialize().

_is_finalized

std::atomic<bool> CommandLineProcess::_is_finalized {false}

private

Referenced by finalize(), and is_finalized().

_is_initialized

std::atomic<bool> CommandLineProcess::_is_initialized {false}

private

Referenced by initialize(), and is_initialized().

_is_running_command

std::atomic<bool> CommandLineProcess::_is_running_command {false}

private

Referenced by cli_thread_start(), and process().

---

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

• src/Server/Common/Server.hpp
• src/Server/Common/Server.cpp