monCmdsImpl.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2020-2025 European Southern Observatory (ESO)
//
// SPDX-License-Identifier: LGPL-3.0-only
 
#ifndef HLCC_TELIF_TELMON_MONCMDSIMPL_HPP
#define HLCC_TELIF_TELMON_MONCMDSIMPL_HPP
 
#include <rad/exceptions.hpp>
#include <rad/smAdapter.hpp>
#include "Telmonif.hpp"
 
#include "telmon/monCmds.rad.hpp"
#include "telmon/logger.hpp"
 
namespace hlcc::telmon {
 
class MonCmdsImpl : public telmonif::AsyncMonCmds {
public:
    explicit MonCmdsImpl(rad::SMAdapter& sm) : m_sm(sm) {
        /* GCH
         * I do the registration of the RejectionHandler
         * in the definition of each command handler method
         * by adding the line:
         *    m_sm.RegisterDefaultRequestRejectHandler<StdCmds::Exit>();
         * This has the advantage of putting the registration one by one
         * together with the code of each handler, making it easy to keep the
         * code aligned and to handle special cases, for example with
         * specific handlers for commands returning something different form
         * a string or not setting an handler for commands that are always available,
         * in any state and will never be rejected.
         * The drawback is a small performance penalty, since it will try to
         * insert the registration in the std::map every time.
         * Nothing will happen, since std::map will not insert a duplicate and will
         * simply ignore the additional insertion.
         * If that is a problem, we might do the registration here in the constructor,
         * but it will be error prone when keeping the code aligned when
         * adding or removing commands
         */
        RAD_TRACE(GetLogger());
    }
 
    virtual ~MonCmdsImpl() {
        RAD_TRACE(GetLogger());
    }
 
    virtual elt::mal::future<std::string> Reload() override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received Reload");
 
        auto ev = std::make_shared<MonCmds::Reload>();
        m_sm.RegisterDefaultRequestRejectHandler<MonCmds::Reload>();
        m_sm.PostEvent(ev);
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> GetModulesLoaded() override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received GetModulesLoaded");
 
        auto ev = std::make_shared<MonCmds::GetModulesLoaded>();
        m_sm.RegisterDefaultRequestRejectHandler<MonCmds::GetModulesLoaded>();
        m_sm.PostEvent(ev);
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetAppIgnore(const std::shared_ptr<telmonif::AppIgnoreData>& ignore_args) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received SetAppIgnore with: Appname  " << ignore_args->getApp_name()
                                    << ", Ignore  " << ignore_args->getIgnore());
 
        auto ev = std::make_shared<MonCmds::SetAppIgnore>(ignore_args->clone());
        m_sm.RegisterDefaultRequestRejectHandler<MonCmds::SetAppIgnore>();
        m_sm.PostEvent(ev);
        return ev->GetPayload().GetReplyFuture();
    }
 
    virtual elt::mal::future<std::string> SetSubsystemIgnore(const std::shared_ptr<telmonif::SubsystemIgnoreData>& ignore_args) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received SetSubsystemIgnore with: Subsystem  " << ignore_args->getSubsystem_name()
                                    << ", Ignore  " << ignore_args->getIgnore());
 
        auto ev = std::make_shared<MonCmds::SetSubsystemIgnore>(ignore_args->clone());
        m_sm.RegisterDefaultRequestRejectHandler<MonCmds::SetSubsystemIgnore>();
        m_sm.PostEvent(ev);
        return ev->GetPayload().GetReplyFuture();
    }
 
private:
    rad::SMAdapter& m_sm;
};
 
}  // namespace hlcc::telmon
 
#endif  // HLCC_TELIF_TELMON_MONCMDSIMPL_HPP