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<ccsinsif::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(GetLogger(), "SetTargetRaDec command received with PresetData - Ra  "
            << preset_data->getRa() << ", Dec  " << preset_data->getDec()
            << ", Epoch  " << preset_data->getEpoch() << " , Parallax  " << preset_data->getParallax()
            << ", Object_name  " << preset_data->getObject_name()
            << ", Proper_motion_ra  " << preset_data->getProper_motion_ra()
            << ", Proper_motion_dec  " << preset_data->getProper_motion_dec()
            << ", Radvel  " << preset_data->getRadvel()
            << ", Rshift  " << preset_data->getRshift()
            << ", System  " << preset_data->getSystem()
            << ", Velocity_offset_ra  " << preset_data->getVelocity_offset_ra()
            << ", Velocity_offset_dec  " << preset_data->getVelocity_offset_dec() );
 
        // 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;
    }
 
 
    // TODO: Add PresetEphem, with PresetEphemArgs.
 
 
    ::elt::mal::future<std::string> SkyOffset(const std::shared_ptr<::ccsinsif::OffsetSkyArgs>& offset_args) override {
        RAD_TRACE(GetLogger());
 
        LOG4CPLUS_INFO(GetLogger(), "SkyOffset command received with Ra "
                << offset_args->getRa() << ", Dec " << offset_args->getDec()
                << ", Field_stabilization  " << offset_args->getField_stabilization()
                << ", Guide_star_param  " << offset_args->getGuide_star_param() );
 
        // WARN do not copy shared_ptr, it is valid only within a scope of this method (CII idiosyncrasy).
        auto ev = std::make_shared<PkCommands::SkyOffset>(offset_args->clone());
 
        m_sm.RegisterDefaultRequestRejectHandler<PkCommands::SkyOffset>();
 
        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), "SkyOffset");
        });
 
        return ret;
    }
 
 
    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