commandsImpl.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_ELTPK_COMMANDSIMPL_HPP
#define HLCC_TELIF_ELTPK_COMMANDSIMPL_HPP
 
#include <rad/smAdapter.hpp>
 
#include <eltpk/commands.rad.hpp>
#include "eltpk/dataContext.hpp"
#include "eltpk/logger.hpp"
 
 
namespace hlcc::eltpk {

class CommandsImpl : public eltpkif::AsyncPointingKernelCommands {
public:
    explicit CommandsImpl(rad::SMAdapter& sm, DataContext& data)
    : m_sm{sm},
      m_data{data} {
 
          /* GCH
           * I do the registration of the RejectionHandler
           * in the definition of each command handler method
           * by adding the line:
           *    m_sm.RegisterDefaultRequestRejectHandler<EventsStd::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 ~CommandsImpl() {
        RAD_TRACE(GetLogger());
    }
 
    elt::mal::future<std::string> SetTargetAltAzPos(const std::shared_ptr<ccscommonif::AltAz>& axes_position) override {
        RAD_TRACE(GetLogger());
 
        LOG4CPLUS_INFO(GetLogger(), "SetTargetAltAzPos command received with Alt:"
                                << axes_position->getAlt() << " Az:" << axes_position->getAz());
 
        // WARN do not just copy shared_ptr, as the AltAz object is valid only within the scope of this method
        // (CII MAL idiosyncrasy). Instead we must clone the object before creating the SM event that references it.
        std::shared_ptr<PkCommands::SetTargetAltAzPos> ev = std::make_shared<PkCommands::SetTargetAltAzPos>(axes_position->clone());
        
        m_sm.RegisterDefaultRequestRejectHandler<PkCommands::SetTargetAltAzPos>();
 
        m_sm.PostEvent(ev);
 
        elt::mal::future<std::string> ret_rad = ev->GetPayload().GetReplyFuture();
        elt::mal::future<std::string> ret = ret_rad.then([](elt::mal::future<std::string> fut_then) {
            return ContinuationCheckRejection(std::move(fut_then), "SetTargetAltAzPos");
        });
 
        return ret;
    }
 

    elt::mal::future<std::string> SetTargetRaDec(const std::shared_ptr<::ccsinsif::PresetArgs>& preset_args) override {
        RAD_TRACE(GetLogger());
 
        std::shared_ptr<ccsinsif::PresetData> preset_data = preset_args->getPreset_data();
 
        LOG4CPLUS_INFO_FMT(GetLogger(), "SetTargetRaDec command received with PresetData - Ra  %1.15f, "
            "Dec  %1.15f, Epoch  %s, Parallax  %1.15f, Object_name  %s, "
            "Proper_motion_ra  %1.15f, Proper_motion_dec  %1.15f, Radvel  %1.15f, "
            "Rshift  %1.15f, Velocity_offset_ra  %1.15f, "
            "Velocity_offset_dec  %1.15f, Wavelength  %1.15f, Time_ephem_utc  %1.15f", 
            preset_data->getTarget_data()->getRa(), preset_data->getTarget_data()->getDec(), preset_data->getTarget_data()->getEpoch().c_str(),
            preset_data->getTarget_data()->getParallax(), preset_data->getTarget_data()->getObject_name().c_str(),
            preset_data->getTarget_data()->getProper_motion_ra(), preset_data->getTarget_data()->getProper_motion_dec(),
            preset_data->getTarget_data()->getRadvel(), preset_data->getTarget_data()->getRshift(),
            preset_data->getTarget_data()->getVelocity_offset_ra(), preset_data->getTarget_data()->getVelocity_offset_dec(),
            preset_data->getTarget_data()->getWavelength(), preset_data->getTarget_data()->getTime_ephem_utc());
 
        // WARN do not just copy shared_ptr, as the PresetArgs object is valid only within the scope of this method
        // (CII MAL idiosyncrasy). Instead we must clone the object before creating the SM event that references it.
        std::shared_ptr<PkCommands::SetTargetRaDec> ev = std::make_shared<PkCommands::SetTargetRaDec>(preset_args->clone());
        
        // The rejection handler will notify the client not only when the SM is outside "On::Operational",
        // but also when the condition/guard "ActionsPreset.IsPresetAllowed" prevents the execution of
        // "ActionsPreset.Start" because of bad PTP sync state.
        m_sm.RegisterDefaultRequestRejectHandler<PkCommands::SetTargetRaDec>();
 
        m_sm.PostEvent(ev);
 
        elt::mal::future<std::string> ret_rad = ev->GetPayload().GetReplyFuture();
        elt::mal::future<std::string> ret = ret_rad.then([](elt::mal::future<std::string> fut_then) {
            return ContinuationCheckRejection(std::move(fut_then), "SetTargetRaDec");
        });
 
        return ret;
    }
 
    ::elt::mal::future<std::string> UpdateTarget(const std::shared_ptr<::ccsinsif::PresetArgs>& preset_args) override {
        RAD_TRACE(GetLogger());
 
        std::shared_ptr<ccsinsif::PresetData> preset_data = preset_args->getPreset_data();
 
        LOG4CPLUS_INFO_FMT(GetLogger(), "UpdateTarget command received with PresetData - Ra  %1.15f, "
            "Dec  %1.15f, Epoch  %s, Parallax  %1.15f, Object_name  %s, "
            "Proper_motion_ra  %1.15f, Proper_motion_dec  %1.15f, Radvel  %1.15f, "
            "Rshift  %1.15f, Velocity_offset_ra  %1.15f, "
            "Velocity_offset_dec  %1.15f, Wavelength  %1.15f, Time_ephem_utc  %1.15f", 
            preset_data->getTarget_data()->getRa(), preset_data->getTarget_data()->getDec(), preset_data->getTarget_data()->getEpoch().c_str(),
            preset_data->getTarget_data()->getParallax(), preset_data->getTarget_data()->getObject_name().c_str(),
            preset_data->getTarget_data()->getProper_motion_ra(), preset_data->getTarget_data()->getProper_motion_dec(),
            preset_data->getTarget_data()->getRadvel(), preset_data->getTarget_data()->getRshift(),
            preset_data->getTarget_data()->getVelocity_offset_ra(), preset_data->getTarget_data()->getVelocity_offset_dec(),
            preset_data->getTarget_data()->getWavelength(), preset_data->getTarget_data()->getTime_ephem_utc());
 
        // WARN do not copy shared_ptr, it is valid only within a scope of this method (CII idiosyncrasy).
        auto ev = std::make_shared<PkCommands::UpdateTarget>(preset_args->clone());
 
        m_sm.RegisterDefaultRequestRejectHandler<PkCommands::UpdateTarget>();
 
        m_sm.PostEvent(ev);
 
        elt::mal::future<std::string> ret_rad = ev->GetPayload().GetReplyFuture();
        elt::mal::future<std::string> ret = ret_rad.then([](elt::mal::future<std::string> fut_then) {
            return ContinuationCheckRejection(std::move(fut_then), "UpdateTarget");
        });
 
        return ret;
    }
 
    [[deprecated("SetObservingWavelength is Deprecated - Use UpdateTarget")]]
    virtual elt::mal::future<std::string> SetObservingWavelength(double wavelength) override {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "SetObservingWavelength command received with Wavelength:" << wavelength);
 
        auto ev = std::make_shared<PkCommands::SetObservingWavelength>(wavelength);
        m_sm.RegisterDefaultRequestRejectHandler<PkCommands::SetObservingWavelength>();
 
        m_sm.PostEvent(ev);
 
        elt::mal::future<std::string> ret_rad = ev->GetPayload().GetReplyFuture();
        elt::mal::future<std::string> ret = ret_rad.then([](elt::mal::future<std::string> fut_then) {
            return ContinuationCheckRejection(std::move(fut_then), "SetObservingWavelength");
        });
 
        return ret;
    }
 
    virtual elt::mal::future<std::string> StopTracking() override {
 
        RAD_TRACE(GetLogger());
        LOG4CPLUS_INFO(GetLogger(), "Received StopTracking");
        auto ev = std::make_shared<PkCommands::StopTracking>();
        m_sm.RegisterDefaultRequestRejectHandler<PkCommands::StopTracking>();
        m_sm.PostEvent(ev);
 
        return ev->GetPayload().GetReplyFuture();
    }
 
private:
    rad::SMAdapter& m_sm;
    DataContext& m_data;

    static std::string ContinuationCheckRejection(elt::mal::future<std::string> future, std::string method_name) {
        std::string reply = future.get(); // the future is (normally) already fulfilled when called from a then-continuation.
        if (reply.find("Request rejected in state") != std::string::npos) { // TODO C++20 use std::string::starts_with.
            LOG4CPLUS_INFO(GetLogger(), method_name << " command rejected by eltpk: " << reply);
        }
        return reply;
    };
};
 
}  // namespace hlcc::eltpk
 
#endif  // HLCC_TELIF_ELTPK_COMMANDSIMPL_HPP