module_main.hpp

Go to the documentation of this file.

#pragma once
 
#include <commrat/commrat.hpp>
#include <commrat/module/module_config.hpp>
#include <commrat/platform/threading.hpp>
#include <rfl.hpp>
#include <rfl/json.hpp>
#include <csignal>
#include <cstdlib>
#include <iostream>
#include <atomic>
#include <string>
 
namespace commrat {
 
// Global flag for signal handling
inline std::atomic<bool> g_shutdown_requested{false};
 
inline void signal_handler(int signal) {
    g_shutdown_requested.store(true);
    std::cout << "\nReceived signal " << signal << ", shutting down...\n";
}
 
template<typename ModuleType, typename Registry>
int module_main(const ModuleConfig& config) {
    try {
        // Install signal handlers
        std::signal(SIGINT, signal_handler);
        std::signal(SIGTERM, signal_handler);
        
        // Create module instance
        std::cout << "Starting " << config.name << " (system_id=" 
                  << static_cast<int>(config.system_id()) << ", instance_id=" 
                  << static_cast<int>(config.instance_id()) << ")\n";
        
        ModuleType module(config);
        
        // Start module (begins subscription protocol, starts threads)
        module.start();
        std::cout << config.name << " running (press Ctrl+C to stop)...\n";
        
        // Wait for shutdown signal (0% CPU - blocking sleep)
        while (!g_shutdown_requested.load()) {
            Time::sleep(Milliseconds(100));
        }
        
        // Stop module (graceful shutdown of threads, unsubscribe)
        std::cout << "Stopping " << config.name << "...\n";
        module.stop();
        
        std::cout << config.name << " stopped successfully\n";
        return g_shutdown_requested.load() ? 130 : 0;  // 130 = SIGINT convention
        
    } catch (const std::exception& e) {
        std::cerr << "ERROR: " << e.what() << "\n";
        return 1;
    } catch (...) {
        std::cerr << "ERROR: Unknown exception\n";
        return 1;
    }
}
 
template<typename ModuleType, typename Registry>
int module_main(int argc, char** argv) {
    try {
        ModuleConfig config;
        
        if (argc != 2) {
            std::cerr << "ERROR: Configuration file required\n";
            std::cerr << "Usage: " << argv[0] << " <config.json>\n";
            return 1;
        }
        
        std::string filename = argv[1];
        if (!filename.ends_with(".json")) {
            std::cerr << "ERROR: Only JSON config files supported (got: " << filename << ")\n";
            std::cerr << "Usage: " << argv[0] << " <config.json>\n";
            return 1;
        }
        
        config = rfl::json::load<ModuleConfig>(filename).value();
        
        // Call the main template function
        return module_main<ModuleType, Registry>(config);
        
    } catch (const std::exception& e) {
        std::cerr << "Fatal error: " << e.what() << "\n";
        return 1;
    }
}
 
} // namespace commrat
 
#define COMMRAT_MODULE_MAIN(ModuleType, Registry) \
    int main(int argc, char** argv) { \
        return commrat::module_main<ModuleType, Registry>(argc, argv); \
    }