actionsStd.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup server
 * @copyright ESO - European Southern Observatory
 * @author
 *
 * @brief ActionsStd class source file.
 */
#include <daq/config.hpp>
 
#include "actionsStd.hpp"
#include <Daqif.hpp>
#include <events.rad.hpp>
#include "dataContext.hpp"
#include "logger.hpp"
 
#include <rad/exceptions.hpp>
#include <rad/getPayload.hpp>
#include <rad/mal/request.hpp>
#include <rad/smEvent.hpp>
 
#include <scxml4cpp/Event.h>
#include <scxml4cpp/Helper.h>
#include <scxml4cpp/State.h>
 
namespace server {
 
 
std::optional<std::string> MakeStatusString(std::list<scxml4cpp::State*>&& states) {
    using scxml4cpp::State;
    std::string status;
    for (auto* s : states) {
        if (!s->isAtomic()) {
            continue;
        }
        // Found a leaf state. Assume it's the third state in hiearchy. If not it means
        // we're in
        State* substate = s;
        if (substate->getId() == "Off") {
            return "Off;";
        }
        State* state = s->getParent();
        if (!state) {
            return std::nullopt;
        }
        State* top = state->getParent();
        if (!top) {
            return std::nullopt;
        }
        if (top->getParent() != nullptr) {
            // active state was nested to deeply.
            return std::nullopt;
        }
        status = state->getId() + ";" + substate->getId();
        return status;
    }
    return std::nullopt;
}
 
 
ActionsStd::ActionsStd(boost::asio::io_service & ios, rad::SMAdapter & sm, DataContext & data)
    : rad::ActionGroup("ActionsStd"),
      m_io_service(ios),
      m_sm(sm),
      m_signal(ios, sm, rad::UniqueEvent(new Events::CtrlC())),
      m_data(data) {
    RAD_TRACE(GetLogger());
 
    m_signal.Add(SIGINT);
    m_signal.Add(SIGTERM);
    m_signal.Install();
}
 
void ActionsStd::Exit(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::Exit>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Exit event has no associated request!");
        return;
    }
    req->SetReplyValue("OK");
    m_io_service.stop();
}
 
void ActionsStd::ExitNoReply(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
    m_io_service.stop();
}
 
void ActionsStd::GetState(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::GetState>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Status event has no associated request!");
        return;
    }
    req->SetReplyValue(m_sm.GetStatus());
}
 
void ActionsStd::GetStatus(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::GetStatus>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Status event has no associated request!");
        return;
    }
    auto status = MakeStatusString(m_sm.GetActiveStates()).value_or("NotOperational;Undefined");
    req->SetReplyValue(status);
}
 
 
void ActionsStd::Stop(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::Stop>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Stop event has no associated request!");
        return;
    }
    req->SetReplyValue("OK");
}
 
void ActionsStd::Init(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::Init>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Init event has no associated request!");
        return;
    }
    req->SetReplyValue("OK");
}
 
void ActionsStd::Enable(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::Enable>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Enable event has no associated request!");
        return;
    }
    req->SetReplyValue("OK");
}
 
void ActionsStd::Disable(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::Disable>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Disable event has no associated request!");
        return;
    }
    req->SetReplyValue("OK");
}
 
void ActionsStd::Reset(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::Reset>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "Reset event has no associated request!");
        return;
    }
    req->SetReplyValue("OK");
}
 
void ActionsStd::SetLogLevel(scxml4cpp::Context * c) {
    RAD_TRACE(GetLogger());
 
    auto req = rad::GetLastEventPayloadNothrow<Events::SetLogLevel>(c);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), "SetLogLevel event has no associated request!");
        return;
    }
 
    auto req_params = req->GetRequestPayload();
    std::string level = req_params->getLevel();
    std::string logger_name = req_params->getLogger();
 
    log4cplus::LogLevelManager& log_mgr = log4cplus::getLogLevelManager();
    // LOG4CPLUS_DEBUG(GetLogger(), "Log level" << level);
    log4cplus::LogLevel ll = log_mgr.fromString(level);
    if (ll == log4cplus::NOT_SET_LOG_LEVEL) {
        req->SetReplyValue("ERR unknown logging level: " + level);
        return;
    }
 
    if (logger_name == "" || logger_name == LOGGER_NAME) {
        GetLogger().setLogLevel(ll);
    } else {
        log4cplus::Logger::getInstance(logger_name).setLogLevel(ll);
    }
    LOG4CPLUS_DEBUG(GetLogger(), "Log level set to " << level << " for logger " << logger_name);
 
    req->SetReplyValue("OK");
}
 
}  // namespace server