actionsLoopClose.hpp

Go to the documentation of this file.

 
#ifndef IFWSLM_ACTIONS_LOOP_CLOSE_HPP
#define IFWSLM_ACTIONS_LOOP_CLOSE_HPP
 
#include "baseLoopActions.hpp"
#include "dataContext.hpp"
#include "logger.hpp"
#include "cmdsImpl.hpp"  // includes events.rad.hpp
 
#include <rad/application.hpp>
#include <rad/smAdapter.hpp>
#include <rad/timer.hpp>
#include <rad/smEvent.hpp>
 
#include <boost/asio.hpp>
 
#include <string>
#include <memory>
 
namespace ifw::slm {
template<int LOOP_INDEX>
void CreateCloseLoopTimer(boost::asio::io_context& ios, rad::SMAdapter& sm, std::unique_ptr<rad::Timer>& timer, int period_sec);
 
// Helper function to create the appropriate trigger event based on loop index
inline rad::UniqueEvent MakeTriggerEvent(int loop_index) {
    switch (loop_index) {
        case 1: return rad::UniqueEvent(new Events::Trigger1());
        case 2: return rad::UniqueEvent(new Events::Trigger2());
        case 3: return rad::UniqueEvent(new Events::Trigger3());
        case 4: return rad::UniqueEvent(new Events::Trigger4());
        case 5: return rad::UniqueEvent(new Events::Trigger5());
        case 6: return rad::UniqueEvent(new Events::Trigger6());
        case 7: return rad::UniqueEvent(new Events::Trigger7());
        case 8: return rad::UniqueEvent(new Events::Trigger8());
        case 9: return rad::UniqueEvent(new Events::Trigger9());
        default: throw std::out_of_range("Invalid loop index: " + std::to_string(loop_index));
    }
}

template<int LOOP_INDEX>
class ActionsLoopClose : public BaseLoopCloseActions {
public:
    using base_type = BaseLoopCloseActions;

    ActionsLoopClose(const std::string& name,
                     rad::Application& appl,
                     rad::ConfigurableActionMgr& action_mgr,
                     DataContext& data,
                     int loop_index,
                     std::shared_ptr<LoopCompletionHandler> completion_handler)
        : base_type(name, appl, action_mgr, data, loop_index, completion_handler),
          m_ios(appl.GetEventLoop()),
          m_sm(appl),
          m_timer_period_sec(CONFIG_DEFAULT_LOOP_PERIOD_SEC) {
        RAD_TRACE(GetLogger());
        ReadTimerPeriodFromConfig();
        LOG4CPLUS_INFO(GetLogger(),
            "Creating ActionsLoop" << LOOP_INDEX << "CloseLoop with timer period " << m_timer_period_sec << " s");
        CreateCloseLoopTimer<LOOP_INDEX>(m_ios, m_sm, m_timer, m_timer_period_sec);
        LOG4CPLUS_INFO(GetLogger(),
            "Created timer for loop " << LOOP_INDEX << ": " << (m_timer ? "success" : "null"));
    }
 
    ~ActionsLoopClose() override {
        RAD_TRACE(GetLogger());
        // Timer is cleaned up by unique_ptr
    }
 
    void Configure(const std::vector<std::string>& keys) override {
        RAD_TRACE(GetLogger());
        base_type::Configure(keys);
        ReadTimerPeriodFromConfig();
    }
 
    void Execute(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
 
        LOG4CPLUS_DEBUG(GetLogger(),
            "Loop " << LOOP_INDEX << " entering CloseLoop, installing timer (period=" << m_timer_period_sec << "s)");
 
        // Reset consecutive failure counter on entering CloseLoop
        m_loop_state.SetFail(false);
        LOG4CPLUS_DEBUG(GetLogger(),
            "Loop " << LOOP_INDEX << " reset consecutive failure counter");
 
        // Call base class to update OLDB state (active=true, state=SL_CLOSED, cycle_start, etc.)
        base_type::Execute(c);
 
        // Install the timer with the configured period
        if (m_timer) {
            m_timer->Install(m_timer_period_sec * 1000);
        }
    }
 
    void Complete(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
 
        // Call base class to update OLDB state (cycle_failure=false)
        base_type::Complete(c);
 
        // Reinstall the timer for the next cycle
        if (m_timer) {
            m_timer->Install(m_timer_period_sec * 1000);
        }
    }
 
    void Abort(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
 
        LOG4CPLUS_DEBUG(GetLogger(),
            "Loop " << LOOP_INDEX << " exiting CloseLoop, cancelling timer");
 
        // Call base class to update OLDB state (cycle_failure=true)
        base_type::Abort(c);
 
        // Cancel the timer to stop execution
        if (m_timer) {
            m_timer->Cancel();
        }
    }
 
    void CycleError(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
 
        LOG4CPLUS_DEBUG(GetLogger(),
            "Loop " << LOOP_INDEX << " CycleError - GenCmd" << LOOP_INDEX << "_Err: timer reinstalled for retry");
 
        // Read max_errors from configuration (fallback to 3)
        int max_errors = 3;
        try {
            max_errors = m_data.GetConfig().GetParam<int>(
                GetLoopConfigKey(m_loop_index, "max_errors"));
        } catch (const std::exception& e) {
            LOG4CPLUS_DEBUG(GetLogger(),
                "Loop " << LOOP_INDEX << " max_errors not configured, using default: " << max_errors);
        }
 
        // Call base class to update OLDB and check consecutive failures
        base_type::CycleError(c);
 
        // If not auto-opening (counter < max_errors), reinstall timer for retry
        if (!m_loop_state.CheckStop(max_errors)) {
            LOG4CPLUS_DEBUG(GetLogger(),
                "Loop " << LOOP_INDEX << " reinstalling timer for retry (period=" << m_timer_period_sec << "s)");
            if (m_timer) {
                m_timer->Cancel();
                m_timer->Install(m_timer_period_sec * 1000);
            }
        }
    }
 
    void InstallTimer(scxml4cpp::Context* c) override {
        RAD_TRACE(GetLogger());
 
        LOG4CPLUS_DEBUG(GetLogger(),
            "Loop " << LOOP_INDEX << " reinstalling timer for next cycle (period=" << m_timer_period_sec << "s)");
 
        // Reset failure counter on successful cycle completion
        m_loop_state.SetFail(false);
 
        // Reinstall the timer for the next cycle
        if (m_timer) {
            m_timer->Install(m_timer_period_sec * 1000);
        }
    }
 
    ActionsLoopClose(const ActionsLoopClose&) = delete;
    ActionsLoopClose& operator=(const ActionsLoopClose&) = delete;
 
private:
    boost::asio::io_context& m_ios;
    rad::SMAdapter& m_sm;
    std::unique_ptr<rad::Timer> m_timer;
    int m_timer_period_sec;
 
    void ReadTimerPeriodFromConfig() {
        try {
            auto& config = m_data.GetConfig();
            std::string config_key = GetLoopConfigKey(m_loop_index, "period_sec");
            int new_period = config.GetParam<int>(config_key);
            if (new_period != m_timer_period_sec) {
                m_timer_period_sec = new_period;
                LOG4CPLUS_INFO(GetLogger(),
                    "Loop " << m_loop_index << " timer period updated to " << m_timer_period_sec << " s (key=" << config_key << ")");
            }
        } catch (const std::exception& e) {
            LOG4CPLUS_INFO(GetLogger(),
                "Loop " << m_loop_index << " timer period not configured (key=" << GetLoopConfigKey(m_loop_index, "period_sec") << "), using default: "
                << m_timer_period_sec << " s");
        }
    }
};
 
// Template implementation using the helper function
template<int LOOP_INDEX>
inline void CreateCloseLoopTimer(boost::asio::io_context& ios, rad::SMAdapter& sm, std::unique_ptr<rad::Timer>& timer, int /*period_sec*/) {
    RAD_TRACE(GetLogger());
    timer = std::make_unique<rad::Timer>(ios, sm, MakeTriggerEvent(LOOP_INDEX));
}
 
 
 
// ===== Type aliases for the 9 loop CloseLoop action classes =====
 
using ActionsLoop1CloseLoop = ActionsLoopClose<1>;
using ActionsLoop2CloseLoop = ActionsLoopClose<2>;
using ActionsLoop3CloseLoop = ActionsLoopClose<3>;
using ActionsLoop4CloseLoop = ActionsLoopClose<4>;
using ActionsLoop5CloseLoop = ActionsLoopClose<5>;
using ActionsLoop6CloseLoop = ActionsLoopClose<6>;
using ActionsLoop7CloseLoop = ActionsLoopClose<7>;
using ActionsLoop8CloseLoop = ActionsLoopClose<8>;
using ActionsLoop9CloseLoop = ActionsLoopClose<9>;
 
} // namespace ifw::slm
 
#endif // IFWSLM_ACTIONS_LOOP_CLOSE_HPP