ServerAction.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#ifndef SERVER_ACTION_H_
#define SERVER_ACTION_H_

#include <fesa-core/Server/AbstractServerAction.h>
#include <fesa-core/Server/RequestEvent.h>
#include <fesa-core/Server/AbstractServerEquipment.h>
#include <fesa-core/Server/AbstractServerDeviceClass.h>
#include <fesa-core/DataStore/AbstractDevice.h>
#include <fesa-core/DataStore/FieldSynchroManager.h>
#include <fesa-core/Synchronization/MultiplexingContext.h>
#include <fesa-core/Persistency/PersistencyManager.h>
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/Diagnostic/Diagnostics.h>

#include <cmw-rda/Data.h>
#include <cmw-log/Logger.h>


namespace
{

const std::string getActionProfDiagTopic = fesa::DiagnosticUtils::getActionProfilingStr;
const std::string setActionProfDiagTopic = fesa::DiagnosticUtils::setActionProfilingStr;

} // namespace


namespace fesa
{

class BasicFilter
{
  public:
    BasicFilter() :
        filter_(NULL)
    {

    }
    void setData(const rdaData& filter)
    {
        filter_ = &filter;
    }
  protected:
    const rdaData* filter_;
};

template<typename DeviceType, typename DataType, typename FilterType = BasicFilter>
class ServerAction: public AbstractServerAction
{
  public:
    ServerAction(ServerActionConfig& actionConfig, const AbstractServiceLocator* serviceLocator, const std::map<std::string, const AbstractServiceLocator*> serviceLocatorRelatedClasses);

    virtual ~ServerAction();

    void execute(RequestEvent* evt, AbstractDevice& dev, const rdaData& filter, rdaData& data, IOType ioType, RequestType reqType);

    void performCommit(MultiplexingContext& pTransactionCtxt, AbstractDevice *transactionDevice);

    void performRollback(MultiplexingContext& pTransactionCtxt, AbstractDevice* transactionDevice);

  protected:

    virtual void execute(RequestEvent* evt, DeviceType* device, DataType& data, const FilterType& filter)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorPropertyExecuteMethodIsNotImplemented.c_str(),
                            name_.c_str());
    };

    virtual void execute(RequestEvent* evt, DeviceType*, DataType& data)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorPropertyExecuteMethodIsNotImplemented.c_str(),
                            name_.c_str());
    };

    virtual void commit(RequestEvent*, DeviceType*)
    {
    };

    virtual void rollback(RequestEvent*, DeviceType*)
    {
    };
};

/****************** IMPLEMENTATION ************************/

template<typename DeviceType, typename DataType, typename FilterType>
inline ServerAction<DeviceType, DataType, FilterType>::ServerAction(ServerActionConfig& actionConfig, const AbstractServiceLocator* serviceLocator, const std::map<std::string, const AbstractServiceLocator*> serviceLocatorRelatedClasses) :
    AbstractServerAction(actionConfig, serviceLocator, serviceLocatorRelatedClasses)
{
}

template<typename DeviceType, typename DataType, typename FilterType>
ServerAction<DeviceType, DataType, FilterType>::~ServerAction()
{
}

template<typename DeviceType, typename DataType, typename FilterType>
inline void ServerAction<DeviceType, DataType, FilterType>::execute(RequestEvent* evt, AbstractDevice& dev,
                                                                    const rdaData& filter, rdaData& data, IOType ioType, RequestType reqType)
{
    const boost::shared_ptr<Diagnostics>& diagnostics = AbstractEquipment::getInstance()->getDiagnostics();
    DiagnosticUtils::DiagnosticMessage diagMsg;
    diagMsg.side = DiagnosticUtils::framework;
    diagMsg.source = DiagnosticUtils::server;
    diagMsg.name = name_;
    
    checkInvalidatingFields(&dev, evt->getMultiplexingContext());
    DeviceType* workingDevice = (DeviceType*) &dev;
    DataType workingData;

    if (ioType == Output)// ioType == Output --> we have a get-action
    {
        diagMsg.action = DiagnosticUtils::start;
        diagnostics->log(getActionProfDiagTopic, diagMsg);
        try
        {
            workingData.setData(data, false, false);
            if (needFilter_)
            {
                FilterType workingFilter;
                workingFilter.setData((rdaData&) filter);
                execute(evt, workingDevice, workingData, workingFilter);
            }
            else
            {
                execute(evt, workingDevice, workingData);
            }
            // Update the value-items linked to fields
            workingData.getRefItems(evt->getMultiplexingContext(), *workingDevice);

            //add common Data to the getaction - data
            int64_t stamp = evt->getMultiplexingContext()->getCycleStamp();
            if (stamp != 0)
            {
                data.insert("cycleStamp", stamp);
            }
            if (reqType != GET)
            {
                int32_t val = reqType;
                data.insert("updateFlags", static_cast<long int>(val));
            }
            const std::string& cycleName = evt->getMultiplexingContext()->getCycleName();
            if (!cycleName.empty())
            {
                data.insert("cycleName", cycleName.c_str());
            }
        }
        catch (FesaException& ex)
        {
            diagMsg.action = DiagnosticUtils::stop;
            diagnostics->log(getActionProfDiagTopic, diagMsg);
            throw;
        }
        diagMsg.action = DiagnosticUtils::stop;
        diagnostics->log(getActionProfDiagTopic, diagMsg);
    }
    else // ioType == Input --> we have a Set-Action
    {
        diagMsg.action = DiagnosticUtils::start;
        diagnostics->log(setActionProfDiagTopic, diagMsg);
        try
        {
            workingData.setData(data, true, partialSetIsAllowed_);
            // Update the fields linked to value-item: this needs to be done prior to the custom ServerAction execution
            // just in case the custom code fires OnDemand event expecting that all the data-fields contain the new setting.
            workingData.setRefItems(evt->getMultiplexingContext(), *workingDevice);
            if (needFilter_)
            {
                FilterType workingFilter;
                workingFilter.setData(const_cast<rdaData&> (filter));
                execute(evt, workingDevice, workingData, workingFilter);
            }
            else
            {
                execute(evt, workingDevice, workingData);
            }
            diagMsg.action = DiagnosticUtils::undefined;
            diagMsg.msg = "Will start commitModifiedFieldSynchronization(): Commit all the setting fields modified by the server action";
            diagnostics->log(setActionProfDiagTopic, diagMsg);

            FieldSynchroManager* pFieldSynchroManager = FieldSynchroManager::getInstance();
            pFieldSynchroManager->commitModifiedFieldSynchronization(evt->getMultiplexingContext());

            diagMsg.msg = "commitModifiedFieldSynchronization() ended";
            diagnostics->log(setActionProfDiagTopic, diagMsg);

            PersistencyManager* thePersistencyManager = PersistencyManager::getInstance();
            // Retrieve the class Name in order to trigger the persistence.
            // Due to Inheritance a ServerAction cannot keep the globalDevice, because in the context
            // of inheritance a derived class may re-use a serverAction defined by a base class but we
            // have to trigger the persistence of the derived class
            AbstractServerDeviceClass* pDevClass = AbstractServerEquipment::getInstance()->getDeviceClassFromDeviceName(std::string(dev.getName()));
            {
                std::ostringstream traceStrStream;
                traceStrStream << "Will trigger persistency for class '" << pDevClass->getName() << "'";
                diagMsg.msg = traceStrStream.str();
                diagnostics->log(setActionProfDiagTopic, diagMsg);
            }
            thePersistencyManager->trigger(pDevClass->getName());
            {
                std::ostringstream traceStrStream;
                traceStrStream << "Persistency for class '" << pDevClass->getName() << "' triggered";
                diagMsg.msg = traceStrStream.str();
                diagnostics->log(setActionProfDiagTopic, diagMsg);
            }
            // It's time to notify potential clients
            notify(*evt->getMultiplexingContext(), dev, SET);

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

        }
        catch (FesaException& ex)
        {
            FieldSynchroManager* pFieldSynchroManager = FieldSynchroManager::getInstance();
            pFieldSynchroManager->abortModifiedFieldSynchronization(evt->getMultiplexingContext());
            diagMsg.action = DiagnosticUtils::stop;
            diagMsg.msg = "";
            diagnostics->log(setActionProfDiagTopic, diagMsg);
            throw;
        }
        diagMsg.action = DiagnosticUtils::stop;
        diagMsg.msg = "";
        diagnostics->log(setActionProfDiagTopic, diagMsg);
    }
}

template<typename DeviceType, typename DataType, typename FilterType>
inline void ServerAction<DeviceType, DataType, FilterType>::performCommit(MultiplexingContext& pTransactionCtxt,
                                                                          AbstractDevice *transactionDevice)
{
    // TODO review the use of shared pointer while tackling transactions
    RequestEvent pEvt(&pTransactionCtxt);
    commit(&pEvt, static_cast<DeviceType*> (transactionDevice));

    //        PersistencyManager* thePersistencyManager = PersistencyManager::getInstance();
    //        thePersistencyManager->trigger(globalDevice_->className_.getAsString());
}

template<typename DeviceType, typename DataType, typename FilterType>
inline void ServerAction<DeviceType, DataType, FilterType>::performRollback(MultiplexingContext& pTransactionCtxt,
                                                                            AbstractDevice* transactionDevice)
{

    RequestEvent pEvt(&pTransactionCtxt);
    rollback(&pEvt, static_cast<DeviceType*> (transactionDevice));

}

} // fesa

#endif // SERVER_ACTION_H_