measurable.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_MEASURABLE_HPP
#define RTCTK_COMPONENTFRAMEWORK_MEASURABLE_HPP
 
#include <optional>
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/jsonPayload.hpp>
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/measCmdsImpl.hpp>
#include <rtctk/componentFramework/rtcComponent.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
namespace rtctk::componentFramework {
namespace detail {
class MeasureContext {
public:
    explicit MeasureContext(const rad::cii::Request<std::string, std::string>& request)
        : m_logger(GetLogger("rtctk")), m_request(request), m_arg() {
        m_arg = JsonPayload::parse(m_request.GetRequestPayload());
    }
    MeasureContext(MeasureContext&&) noexcept = default;
 
    const JsonPayload& GetArg() const noexcept {
        return m_arg;
    }

    void SetResult(const JsonPayload& result) {
        m_result = result.dump();
    }

    void SendReply() noexcept {
        try {
            m_request.SetReplyValue(m_result);
        } catch (const std::exception& exception) {
            LOG4CPLUS_ERROR(
                m_logger, "MeasureContext::SendReply: Failed to send reply: " << exception.what());
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "MeasureContext::SendReply: Failed to send reply with unknown exception.");
        }
    }

    void SendErrorReply(std::exception_ptr eptr) noexcept {
        try {
            m_request.SetException(RequestFailed(NestedExceptionPrinter(std::move(eptr)).Str()));
        } catch (const RtctkException& exception) {
            LOG4CPLUS_ERROR(
                m_logger,
                "MeasureContext::SendErrorReply: Failed to send reply: " << exception.what());
        } catch (...) {
            LOG4CPLUS_ERROR(
                m_logger,
                "MeasureContext::SendErrorReply: Failed to send reply with unknown exception.");
        }
    }
 
private:
    log4cplus::Logger& m_logger;
    rad::cii::Request<std::string, std::string> m_request;
    JsonPayload m_arg;
    std::string m_result;
};
}  // namespace detail

template <typename Super>
struct Measurable : Super {
    static_assert(std::is_base_of_v<RtcComponent, Super>, "'Measurable' requires 'RtcComponent'");

    class BizLogicIf : public Super::BizLogicIf {
    public:
        virtual JsonPayload ActivityMeasuring(StopToken stop_token, const JsonPayload& arg) {
            (void)stop_token;
            return {"42"};
        }

        virtual bool GuardMeasuringAllowed(const JsonPayload& arg) {
            return true;
        }
    };

    class InputStage : public Super::InputStage {
    public:
        using Super::InputStage::InputStage;
 
        void Start() override {
            Super::InputStage::Start();
 
            MeasCmdsImpl::Register(this->m_replier, this->m_engine);
        }
    };

    class OutputStage : public Super::OutputStage {
    public:
        OutputStage(StateMachineEngine& engine, BizLogicIf& bl) : Super::OutputStage(engine, bl) {
            // Handlers ###################################################################
 
            engine.RegisterRejectHandler<events::Measure, RequestRejected>();
 
            m_measure_success_handler = [this] {
                this->m_engine.PostEvent(std::make_unique<events::MeasureDone>());
            };
 
            m_measure_error_handler = [this](std::exception_ptr eptr) {
                this->m_engine.PostEvent(std::make_unique<events::MeasureError>(std::move(eptr)));
            };
 
            // No Disable in states ###############################################################
 
            this->m_no_disable_in_states.emplace_back("On::Operational:Measure:Busy");
 
            // No Update in states ################################################################
 
            this->m_no_update_in_states.emplace_back("On::Operational:Measure:Busy");
 
            // No Measure in states ###############################################################
 
            this->m_no_measure_in_states.emplace_back("On:Update:Busy");
 
            // Guards #####################################################################
 
            engine.RegisterGuardStatic<events::Measure>(
                "GuardMeasuringAllowed", [this](const events::Measure& ev) {
                    auto act_state = this->m_engine.GetState();
                    for (auto& s : m_no_measure_in_states) {
                        if (act_state.find(s) != std::string::npos) {
                            return false;
                        }
                    }
                    detail::MeasureContext ctx(ev.GetPayload());
                    if (static_cast<BizLogicIf&>(this->m_logic)
                            .GuardMeasuringAllowed(ctx.GetArg())) {
                        // Measure is allowed so context is stored.
                        assert(!m_measure_ctx);
                        m_measure_ctx.emplace(std::move(ctx));
                        return true;
                    }
                    return false;
                });
 
            // Activities #####################################################################
            engine.RegisterActivity(
                "ActivityMeasuring",
                [this](StopToken stop_token) {
                    assert(m_measure_ctx);
                    JsonPayload result =
                        static_cast<BizLogicIf&>(this->m_logic)
                            .ActivityMeasuring(std::move(stop_token), m_measure_ctx->GetArg());
                    // note: SetResult may throw
                    m_measure_ctx->SetResult(result);
                },
                m_measure_success_handler,
                m_measure_error_handler);
 
            // Actions #####################################################################
            engine.RegisterAction("ActionMeasuringDone", [this](auto c) {
                assert(m_measure_ctx);
                m_measure_ctx->SendReply();
                m_measure_ctx.reset();
            });
 
            engine.RegisterActionStatic<events::MeasureError>(
                "ActionMeasuringFailed", [this](const events::MeasureError& ev) {
                    assert(m_measure_ctx);
                    m_measure_ctx->SendErrorReply(ev.GetPayload());
                    m_measure_ctx.reset();
                });
        }
 
    protected:
        std::optional<detail::MeasureContext> m_measure_ctx;
        std::function<void()> m_measure_success_handler;
        std::function<void(std::exception_ptr)> m_measure_error_handler;
        std::list<std::string> m_no_measure_in_states;
    };

    class ModelBuilder : public Super::ModelBuilder {
    public:
        explicit ModelBuilder(StateMachineEngine& engine) : Super::ModelBuilder(engine) {
            // clang-format off
            this->mm.ModStateType("On::Operational", Parallel);
 
            this->mm.AddState(Composite, "On::Operational:Measure:",        "On::Operational");
            this->mm.AddState(Initial,   "On::Operational:Measure:Initial", "On::Operational:Measure:");
            this->mm.AddState(Simple,    "On::Operational:Measure:Idle",    "On::Operational:Measure:");
            this->mm.AddState(Simple,    "On::Operational:Measure:Busy",    "On::Operational:Measure:",   "ActivityMeasuring");
 
            this->mm.AddTrans("On::Operational:Measure:Initial"  , "On::Operational:Measure:Idle" );
            this->mm.AddTrans("On::Operational:Measure:Idle"     , "On::Operational:Measure:Busy",  events::Measure::ID,      "GuardMeasuringAllowed");
            this->mm.AddTrans("On::Operational:Measure:Busy"     , "On::Operational:Measure:Idle",  events::MeasureDone::ID,  "",  "ActionMeasuringDone");
            this->mm.AddTrans("On::Operational:Measure:Busy"     , "On::Operational:Measure:Idle",  events::MeasureError::ID, "",  "ActionMeasuringFailed");
            // clang-format on
        }
    };
};
 
}  // namespace rtctk::componentFramework
 
#endif