ConsoleApplication.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CONSOLIX_CONSOLE_APPLICATION_HPP_INCLUDED
#define _CONSOLIX_CONSOLE_APPLICATION_HPP_INCLUDED

 
#include <csignal>
 
namespace consolix {

    class ConsoleApplication {
    public:

        static ConsoleApplication& get_instance() {
            static ConsoleApplication* instance = new ConsoleApplication();
            return *instance;
        }

        template <typename Component, typename... Args>
        std::shared_ptr<Component> add(Args&&... args) {
            return m_manager.add<Component>(std::forward<Args>(args)...);
        }

        void add(std::shared_ptr<IAppComponent> component) {
            m_manager.add(std::move(component));
        }

        void init() {
            try {
                while (!m_stopping && !m_manager.initialize()) {
                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
                }
                if (m_stopping) {
                    cleanup(0);
                }
            } catch (const std::exception& e) {
                handle_fatal_exception(e);
            }
        }

        template <typename InitAction>
        void init(InitAction init_action) {
            try {
                while (!m_stopping && !m_manager.initialize()) {
                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
                }
                if (m_stopping) {
                    cleanup(0);
                }
                init_action();
                if (m_stopping) {
                    cleanup(0);
                }
            } catch (const std::exception& e) {
                handle_fatal_exception(e);
            }
        }

        void run() {
            if (m_running) return;
            m_running = true;
            setup_signal_handlers();
            init();
            lifecycle_loop();
        }

        template <typename IterationAction>
        void run(IterationAction iteration_action) {
            if (m_running) return;
            m_running = true;
            setup_signal_handlers();
            init();
            lifecycle_loop(iteration_action);
        }

        void stop() {
            if (m_stopping) return;
            m_stopping = true;
        }

        void shutdown(int signal) {
            cleanup(signal);
        }
 
    private:
        AppComponentManager m_manager;
        std::atomic<bool>   m_init{false};
        std::atomic<bool>   m_running{false};  
        std::atomic<bool>   m_stopping{false};
        std::atomic<bool>   m_cleanup{false}; 

        void setup_signal_handlers() {
#           if defined(_WIN32) || defined(_WIN64)
            SetConsoleCtrlHandler(console_handler, TRUE);
#           else
            std::signal(SIGINT, signal_handler);
            std::signal(SIGTERM, signal_handler);
#           endif
            std::atexit(on_exit_handler);
        }

        void cleanup(int exit_code, bool wait_for_press = false) {
            if (m_cleanup) return;
            m_cleanup = true;
 
#           if CONSOLIX_USE_LOGIT == 1
            LOGIT_PRINT_INFO("Cleaning up application for exit code: ", exit_code);
            try {
                m_manager.shutdown(exit_code);
            } catch (const std::exception& e) {
                LOGIT_FATAL(e);
            }
            try {
                ServiceLocator::get_instance().clear_all();
            } catch (const std::exception& e) {
                LOGIT_FATAL(e);
            }
            LOGIT_SHUTDOWN();
#           else
            try {
                m_manager.shutdown(exit_code);
            } catch (...) {}
            try {
                ServiceLocator::get_instance().clear_all();
            } catch (...) {}
#           endif
            if (wait_for_press) {
                CONSOLIX_STREAM() << "Press Enter to exit..." << std::endl;
                std::cin.get();
            }
            std::exit(exit_code);
        }

        void handle_fatal_exception(const std::exception& e) {
#           if CONSOLIX_USE_LOGIT == 1
            LOGIT_PRINT_FATAL("Unhandled exception: ", e.what());
#           endif //
            cleanup(-1, static_cast<bool>(CONSOLIX_WAIT_ON_ERROR));
        }

        template <typename IterationAction>
        void lifecycle_loop(IterationAction iteration_action) {
            try {
                while (!m_stopping) {
                    m_manager.process();
                    iteration_action();
                }
                cleanup(0);
            } catch (const std::exception& e) {
                handle_fatal_exception(e);
            }
        }

        void lifecycle_loop() {
            try {
                while (!m_stopping) {
                    m_manager.process();
                }
                cleanup(0);
            } catch (const std::exception& e) {
                handle_fatal_exception(e);
            }
        }

        static void on_exit_handler() {
            ConsoleApplication::get_instance().shutdown(0);
        }
 
#       if defined(_WIN32) || defined(_WIN64)

        static BOOL WINAPI console_handler(DWORD win_event) {
            switch (win_event) {
            case CTRL_C_EVENT:
                log_event("CTRL_C_EVENT");
                break;
            case CTRL_CLOSE_EVENT:
                log_event("CTRL_CLOSE_EVENT");
                break;
            case CTRL_LOGOFF_EVENT:
                log_event("CTRL_LOGOFF_EVENT");
                break;
            case CTRL_SHUTDOWN_EVENT:
                log_event("CTRL_SHUTDOWN_EVENT");
                break;
            default:
                log_event("UNKNOWN_EVENT");
                break;
            }
            ConsoleApplication::get_instance().shutdown(event_to_exit_code(win_event));
            return FALSE;
        }

        static void log_event(const char* event_name) {
#           if CONSOLIX_USE_LOGIT == 1
            LOGIT_PRINT_INFO("Console event received: ", event_name);
#           endif
        }

        static int event_to_exit_code(DWORD win_event) {
            switch (win_event) {
            case CTRL_C_EVENT:
                return SIGINT;
            default:
                return SIGTERM;
            };
        }
 
#       else

        static void signal_handler(int exit_code) {
            switch (exit_code) {
            case SIGINT:
                handle_signal("SIGINT", exit_code);
                break;
            case SIGTERM:
                handle_signal("SIGTERM", exit_code);
                break;
            default:
                handle_signal("UNKNOWN_SIGNAL", exit_code);
                break;
            }
        }

        static void handle_signal(const char* signal_name, int exit_code) {
#           if CONSOLIX_USE_LOGIT == 1
            LOGIT_PRINT_INFO("POSIX signal received: ", signal_name, ", exit code: ", exit_code);
#           endif
            cleanup(exit_code);
        }
 
#       endif
 
        ConsoleApplication() = default;
        ~ConsoleApplication() = default;
 
        // Deleting copy and move constructors and assignment operators to enforce singleton.
        ConsoleApplication(const ConsoleApplication&) = delete;
        ConsoleApplication& operator=(const ConsoleApplication&) = delete;
        ConsoleApplication(ConsoleApplication&&) = delete;
        ConsoleApplication& operator=(ConsoleApplication&&) = delete;
    }; // ConsoleApplication
 
}; // namespace consolix
 
#endif // _CONSOLIX_CONSOLE_APPLICATION_HPP_INCLUDED