replier.hpp

Go to the documentation of this file.

 
#ifndef RAD_MAL_REPLIER_HPP
#define RAD_MAL_REPLIER_HPP
 
#include <rad/assert.hpp>
#include <rad/logger.hpp>
 
#include <mal/Cii.hpp>
#include <mal/Mal.hpp>
#include <mal/utility/LoadMal.hpp>
 
#include <thread>
 
namespace rad {
namespace cii {
 
class Replier final {
   public:
    explicit Replier(const elt::mal::Uri& uri,
            const std::optional<elt::mal::Mal::Properties> mal_properties = {})
        : m_server(nullptr) {
        RAD_TRACE(GetLogger());
 
        m_server = elt::mal::CiiFactory::getInstance().createServer(
            uri, elt::mal::rr::qos::QoS::DEFAULT,
            mal_properties ? *mal_properties : elt::mal::Mal::Properties());
        RAD_ASSERTPTR(m_server);
 
        LOG4CPLUS_DEBUG(GetLogger(), "Created MAL server for <" << uri << ">");
 
        m_thread = std::thread([this]() { m_server->run(); });
    }
 
    ~Replier() {
        RAD_TRACE(GetLogger());
 
        RAD_ASSERTPTR(m_server);
        try {
            m_server->close();
            if (m_thread.joinable() == false) {
                LOG4CPLUS_ERROR(GetLogger(), "Thread not joinable!");
                return;
            }
            m_thread.join();
        } catch (...) {
            LOG4CPLUS_ERROR(GetLogger(), "Unknown exception when closing MAL server!");
        }
        LOG4CPLUS_DEBUG(GetLogger(), "Terminated MAL server thread.");
    }
 
    template <class SERVICE_TYPE>
    void RegisterService(const std::string& name, std::shared_ptr<SERVICE_TYPE> service) {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_server);
        std::shared_ptr<elt::mal::rr::RrEntity> rrservice = service;
        m_server->registerService<SERVICE_TYPE, false>(name, rrservice);
        LOG4CPLUS_DEBUG(GetLogger(), "Registered service <" << name << ">");
    }
 
    void UnregisterService(const std::string& name) {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_server);
        m_server->unregisterService(name);
        LOG4CPLUS_DEBUG(GetLogger(), "Unregistered service <" << name << ">");
    }
 
#if 0
    void Start() {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_mal_server);
        m_thread = std::thread(&Replier::Run, this);
        LOG4CPLUS_DEBUG(GetLogger(), "Started MAL server thread.");
    }
 
    void Run() {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_mal_server);
        m_mal_server->run();
    }
 
    void Stop() {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_mal_server);
        m_mal_server->close();
        if (m_thread.joinable() == false) {
            LOG4CPLUS_ERROR(GetLogger(), "Thread not joinable!");
            return;
        }
        m_thread.join();
        LOG4CPLUS_DEBUG(GetLogger(), "Terminated MAL server thread.");
    }
#endif
 
    Replier(const Replier&) = delete;
    Replier& operator=(const Replier&) = delete;
 
   private:
    std::unique_ptr<elt::mal::rr::Server> m_server;  // MAL Server.
    std::thread m_thread;                            // Thread used to run the MAL Server.
};
 
#if 0
template<typename SERVICE_TYPE, typename INTERFACE_TYPE>
class Replier {
public:
    Replier(const std::string& serverUri,
            const std::string& malType,
            const std::string& serviceName,
            rad::SMAdapter& sm) : m_mal_server(nullptr) {
        RAD_TRACE(GetLogger());
 
        elt::mal::CiiFactory& factory = elt::mal::CiiFactory::getInstance();
 
        elt::mal::Mal::Properties mal_properties;
        auto malInstance = elt::mal::loadMal(malType, mal_properties);
 
        elt::mal::Uri sUri = elt::mal::Uri(serverUri);
        std::string scheme = sUri.scheme().to_string();
        factory.registerMal(scheme, malInstance);
        LOG4CPLUS_DEBUG(GetLogger(), "Registered MAL.");
 
        m_mal_server = factory.createServer(sUri, elt::mal::rr::qos::QoS::DEFAULT, mal_properties);
 
        std::shared_ptr<elt::mal::rr::RrEntity> serviceImpl = std::make_shared<INTERFACE_TYPE>(sm);
        m_mal_server->registerService<SERVICE_TYPE, false>(serviceName, serviceImpl);
 
        LOG4CPLUS_DEBUG(GetLogger(), "Registered MAL <" <<  malType << "> service <" << serviceName << "> on <" << sUri << ">");
    }
 
    void Start() {
        RAD_TRACE(GetLogger());
 
        if (m_mal_server != nullptr) {
            m_thread = std::thread(&Replier::Run, this);
            LOG4CPLUS_DEBUG(GetLogger(), "Started MAL server thread.");
        }
    }
 
    void Run() {
        RAD_TRACE(GetLogger());
 
        if (m_mal_server != nullptr) {
            m_mal_server->run();
        }
    }
 
    void Stop() {
        RAD_TRACE(GetLogger());
 
        if (m_mal_server != nullptr) {
            m_mal_server->close();
            if (m_thread.joinable() == false) {
                std::cout << "Thread not joinable!\n";
                return;
            }
            m_thread.join();
            LOG4CPLUS_DEBUG(GetLogger(), "Terminated MAL server thread.");
        }
    }
 
    Replier(const Replier&) = delete;
    Replier& operator= (const Replier&) = delete;
 
private:
    std::unique_ptr<elt::mal::rr::Server> m_server;
    std::thread m_thread;
};
#endif
 
}  // namespace cii
}  // namespace rad
 
#endif  // RAD_MAL_REPLIER_HPP