AbstractRTAction.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/RealTime/AbstractRTAction.h>

#include <fesa-core/RealTime/RTEvent.h>
#include <fesa-core/RealTime/AbstractRTEquipment.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/DataStore/EquipmentData.h>
#include <fesa-core/Core/NotificationIDManager.h>
#include <fesa-core/Core/NotificationProducer.h>
#include <fesa-core/Core/AbstractServiceLocator.h>
#include <fesa-core/Core/MessageTypes.h>
#include <fesa-core/Diagnostic/Diagnostics.h>
#include <fesa-core/Core/OnDemandProducer.h>

#include <cmw-log/Logger.h>


namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.RealTime.AbstractRTAction");
const std::string diagTopic = fesa::DiagnosticUtils::rtActionProfilingStr;
} // namespace


namespace fesa
{

AbstractRTAction::AbstractRTAction(RTActionConfig& rtActionConfig, const AbstractServiceLocator* serviceLocator, const std::map<std::string, const AbstractServiceLocator*> serviceLocatorRelatedClasses) :
        AbstractAction(rtActionConfig.actionName_,rtActionConfig.className_,serviceLocator,serviceLocatorRelatedClasses),
        eventName_(rtActionConfig.eventName_),
        selectionCriterion_(rtActionConfig.selectionCriterion_),
        manuallyNotifiedPropertiesCol_(rtActionConfig.manuallyNotifiedPropertiesCol_),
        eventSourceName_(rtActionConfig.eventSourceName_),
        abstractDeviceCol_(rtActionConfig.deviceCol_),
        globalDevice_(rtActionConfig.globalDevice_),
        manualNotificationMessage_(NULL),
        automaticallyNotifiedPropertiesCol_(rtActionConfig.automaticallyNotifiedPropertiesCol_)

{
        NotificationIDManager* notIDGen = NotificationIDManager::getInstance();

        std::set<std::string> deviceNames;
        for (std::vector<AbstractDevice*>::iterator devIter = abstractDeviceCol_.begin(); devIter != abstractDeviceCol_.end(); devIter++)
        {
                deviceNames.insert((*devIter)->getName());
        }
        // If the flag tells that the list of properties to be notified contains at least one globalProperty,
        // the global device name is inserted.
        if (rtActionConfig.isGlobalPropertyToBeNotified_)
                deviceNames.insert(globalDevice_->getName());

        if (!automaticallyNotifiedPropertiesCol_.empty())
                notificationID_ = notIDGen->createNotificationID(automaticallyNotifiedPropertiesCol_, deviceNames, className_);
        else
                notificationID_ = NO_NOTIFICATION;

        theNotificationProducer_ = NotificationProducer::getInstance();

        // Check if all the device collection shares the same timingDomain including the global device
        devicesShareTimingDomain_ = true;
        timingDomain_.assign("Undefined");
        for (uint32_t i = 0; i < (abstractDeviceCol_.size()); i++)
        {
                if ((abstractDeviceCol_[i])->isMultiplexed())
                {
                        if (timingDomain_.compare(abstractDeviceCol_[i]->timingDomain.getAsString()))
                        {
                                //if it is the first time
                                if (!timingDomain_.compare("Undefined"))
                                {
                                        timingDomain_.assign(abstractDeviceCol_[i]->timingDomain.getAsString());
                                }
                                else
                                {
                                        devicesShareTimingDomain_ = false;
                                        timingDomain_.assign("Undefined");
                                        break;
                                }
                        }
                }
        }
        if (globalDevice_->isMultiplexed() && devicesShareTimingDomain_ == true)
        {
                if (timingDomain_.compare(globalDevice_->timingDomain.getAsString()))
                {
                        devicesShareTimingDomain_ = false;
                        timingDomain_.assign("Undefined");
                }
        }

        if (!manuallyNotifiedPropertiesCol_.empty())
        {
                this->manualNotificationMessage_ = new ManualNotificationMessage(rtActionConfig.className_);
        }
}

AbstractRTAction::~AbstractRTAction()
{

        std::vector<AbstractDevice*>::iterator devices;

        // DO NOT REMOVE THE DEVICES, do so in the device factory
        manuallyNotifiedPropertiesCol_.clear();
        automaticallyNotifiedPropertiesCol_.clear();
        theNotificationProducer_ = NULL;
}

void AbstractRTAction::executeAction(RTEvent* event)
{
    // Check if event's timing domain is coherent with the timing domain of the device collection
    std::string ctxTimingDomainName = event->getMultiplexingContext()->getTimingDomainName();
    if (!ctxTimingDomainName.empty())
    {
        if (devicesShareTimingDomain_ == false)
        {
            throw FesaException(__FILE__, __LINE__, FesaErrorDevColHasMultipleTimingDomains.c_str());
        }
        else
        {
            if (timingDomain_.compare("Undefined")) // FIXME what's that double if logic?
            {
                if (timingDomain_.compare(ctxTimingDomainName))
                {
                    throw FesaException(__FILE__, __LINE__, FesaErrorInconsistentTimingDomain.c_str());
                }
            }
        }
    }
    const boost::shared_ptr<Diagnostics>& diagnostics = AbstractEquipment::getInstance()->getDiagnostics();
    DiagnosticUtils::DiagnosticMessage diagMsg;
    diagMsg.side = DiagnosticUtils::framework;
    diagMsg.source = DiagnosticUtils::rt;
    diagMsg.name = name_;
    diagMsg.action = DiagnosticUtils::start;
    diagMsg.msg = "";
    diagnostics->log(diagTopic, diagMsg);

    serviceLocator_->synchronizeSettingFields(*(event->getMultiplexingContext()));
    // reset the manual notification message
    if (this->manualNotificationMessage_ != NULL )
    {
        this->manualNotificationMessage_->reset();
    }

    try
    {
        execute(event);
        (completedActionCount_.current_)++;

        //Trigger all OnDemand-Event-Sources which need to be triggered automatically
        triggerAllAutomaticallyTriggeredOnDemandEventSources(event->getMultiplexingContext());

        if (notificationID_ != NO_NOTIFICATION && automaticallyNotifiedPropertiesCol_.empty() == false)
        {
            EquipmentData* eqData = EquipmentData::getInstance();
            if (*(eqData->serverUp_))
            {
                theNotificationProducer_->sendAutomaticNotification(notificationID_, *event->getMultiplexingContext(), 0);
                if(logger.isLoggable(CMW::Log::Level::LL_TRACE))
                {
                    std::ostringstream msg;
                    msg << "Notifying the server from " << className_ << "::" << name_ << " (id=" << notificationID_ << ").";
                    LOG_TRACE_IF(logger, msg.str());
                }
            }
        }
        else if (logger.isLoggable(CMW::Log::Level::LL_TRACE))
        {
            std::ostringstream msg;
            msg << "No server notification for " << className_ << "::" << name_ << ": id=" << notificationID_
                            << " & autoNotification=" << automaticallyNotifiedPropertiesCol_.empty() << ".";
            LOG_TRACE_IF(logger, msg.str());
        }
    }
    catch (FesaException& ex)
    {
        abortedActionCount_++;
        diagMsg.action = DiagnosticUtils::stop;
        diagnostics->log(diagTopic, diagMsg);
        throw;
    }
    diagMsg.action = DiagnosticUtils::stop;
    diagnostics->log(diagTopic, diagMsg);
}

void AbstractRTAction::sendManualNotification(MultiplexingContext* muxContext)
{
        //if the Server part is down, throw an exception
        EquipmentData* eqData = EquipmentData::getInstance();
        if (!(*(eqData->serverUp_)))
        {
                return;
        }

        if (this->manualNotificationMessage_ != NULL)
        {
                this->manualNotificationMessage_->muxContext_ = muxContext;
                theNotificationProducer_->sendManualNotification(*manualNotificationMessage_);
        }

}

}