malRequestActivity.hpp

Go to the documentation of this file.

#ifndef IFWSLM_MAL_REQUEST_ACTIVITY_HPP
#define IFWSLM_MAL_REQUEST_ACTIVITY_HPP
 
#include <ifw/slm/framework/baseLoopActions.hpp>
#include <ifw/slm/framework/serviceResolver.hpp>
 
#include <rad/mal/requestor.hpp>
 
#include <memory>
#include <string>
 
namespace ifw::slm {

template<class Interface>
class MalRequestLoopActivity : public BaseLoopExecuteActivity {
public:
    MalRequestLoopActivity(const std::string& id,
                           rad::SMAdapter& sm,
                           DataContext& data,
                           int loop_index,
                           LoopCompletionHandler* completion_handler = nullptr,
                           const std::string& endpoint_param = "params/cmd_endpoint",
                           int connect_timeout_ms = 5000,
                           int reply_timeout_ms = 20000)
        : BaseLoopExecuteActivity(id, sm, data, loop_index, completion_handler),
          m_endpoint_param(endpoint_param),
          m_connect_timeout_ms(connect_timeout_ms),
          m_reply_timeout_ms(reply_timeout_ms) {
        // Capture the raw endpoint spec on the construction (main/config)
        // thread. The service name is resolved to a live URI later, at first
        // use (HTTP resolution is thread-safe).
        m_endpoint_spec = GetLoopParam<std::string>(m_endpoint_param, std::string(""));
    }
 
protected:
    std::string Endpoint() const {
        // WriteSecondaryLoopConfig echoes the per-loop params to OLDB, so an
        // operator can retarget the loop at runtime by writing this key. Prefer
        // that live value and fall back to the configured spec captured at
        // construction.
        std::string spec;
        if (!ReadLoopOldb<std::string>(m_endpoint_param, spec) || spec.empty()) {
            spec = m_endpoint_spec;
        }
        return ResolveEndpoint(spec, m_resolver, m_namespace);
    }

    auto Remote() {
        return Requestor().GetInterface();
    }

    rad::cii::Requestor<Interface>& Requestor() {
        if (!m_requestor) {
            m_endpoint = Endpoint();
            elt::mal::Mal::Properties props;
            props["zpb.rr.ConnectTimeoutMs"] = std::to_string(m_connect_timeout_ms);
            props["zpb.rr.ReplyTimeoutMs"]   = std::to_string(m_reply_timeout_ms);
            m_requestor = std::make_unique<rad::cii::Requestor<Interface>>(
                elt::mal::Uri(m_endpoint), props);
            LOG4CPLUS_INFO(m_logger, "Loop " << m_loop_index
                << " MAL requestor created for " << m_endpoint);
        }
        return *m_requestor;
    }
 
private:
    std::string m_endpoint_param;
    std::string m_endpoint_spec;   
    std::string m_endpoint;
    int m_connect_timeout_ms;
    int m_reply_timeout_ms;
    ServiceResolver m_resolver;
    std::string m_namespace{ServiceResolver::DefaultNamespace()};
    std::unique_ptr<rad::cii::Requestor<Interface>> m_requestor;
};
 
} // namespace ifw::slm
 
#endif // IFWSLM_MAL_REQUEST_ACTIVITY_HPP