SetDiagnosticSetting.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Server/SetDiagnosticSetting.h>

#include <fesa-core/Server/RequestEvent.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/Diagnostic/DiagnosticUtils.h>
#include <fesa-core/Diagnostic/Diagnostics.h>

#include <cmw-rda/Data.h>
#include <cmw-log/Logger.h>
#include <cmw-log/FilterLogger.h>
#include <cmw-log/AppenderManager.h>
#include <cmw-log/LogException.h>
#include <cmw-log-stomp/StompAppenderBuilder.h>


namespace
{

const std::string serverActionTopic = fesa::DiagnosticUtils::setActionProfilingStr;
const std::string appenderName = "DiagStompLogs";
const std::string socketType = "udp";
const std::string domain = "FESA";
const std::string subDomain = "TEST";
const std::string source = "TEST";
CMW::Log::Appender* diagStompAppender = NULL;
CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.Server.SetDiagnosticSetting");

} // namespace


namespace fesa
{

SetDiagnosticSetting::SetDiagnosticSetting(ServerActionConfig& serverActCfg, const AbstractServiceLocator* serviceLocator, const std::map<std::string, const AbstractServiceLocator*> serviceLocatorRelatedClasses) :
    AbstractServerAction(serverActCfg, serviceLocator, serviceLocatorRelatedClasses)
{
}


SetDiagnosticSetting::~SetDiagnosticSetting()
{
}


bool SetDiagnosticSetting::needFilter()
{
    return false;
}


void SetDiagnosticSetting::execute(RequestEvent* event, AbstractDevice& device, const rdaData& filter,
                                   rdaData& data, IOType ioType, RequestType requestType)
{
    const boost::shared_ptr<Diagnostics>& diagnostics = AbstractEquipment::getInstance()->getDiagnostics();
    const DiagnosticUtils::DiagnosticTopics& frameworkTopics = diagnostics->getTopics(DiagnosticUtils::framework);
    const DiagnosticUtils::DiagnosticTopics& userTopics = diagnostics->getTopics(DiagnosticUtils::user);
    DiagnosticUtils::DiagnosticMessage diagMsg;
    diagMsg.side = DiagnosticUtils::framework;
    diagMsg.source = DiagnosticUtils::server;
    diagMsg.name = getName();
    diagMsg.action = DiagnosticUtils::start;
    diagnostics->log(serverActionTopic, diagMsg);
    GlobalDevice& globalDevice = static_cast<GlobalDevice&>(device);
    MultiplexingContext* context = event->getMultiplexingContext();
    bool enabled = false;
    if (data.contains("enableDiagMode"))
    {
        enabled = data.extractBoolean("enableDiagMode");
    }
    // Disable diagnostics
    if (enabled == false)
    {
        const bool diagEnabled = globalDevice.enableDiagMode.get(context);
        if (diagEnabled == true) // If diagnostics were enabled before
        {
            for (DiagnosticUtils::DiagnosticTopics::const_iterator iter = frameworkTopics.begin(); iter != frameworkTopics.end(); ++iter)
            {
                const std::string topicName = iter->second;
                diagnostics->disable(DiagnosticUtils::framework, topicName);
            }
            for (DiagnosticUtils::DiagnosticTopics::const_iterator iter = userTopics.begin(); iter != userTopics.end(); ++iter)
            {
                const std::string topicName = iter->second;
                diagnostics->disable(DiagnosticUtils::user, topicName);
            }
            CMW::Log::AppenderManager::unregisterAppender(appenderName);
            delete diagStompAppender;
            diagStompAppender = NULL;
        }
        globalDevice.enableDiagMode.set(false, context);
        return;
    }
    globalDevice.enableDiagMode.set(true, context);
    if (data.contains("hostName") && data.contains("portNumber"))
    {
        const std::string host = data.getString("hostName");
        const int32_t port = static_cast<int32_t>(data.extractInt("portNumber"));
        globalDevice.hostName.set(host.c_str(), context);
        globalDevice.portNumber.set(port, context);
        // TODO: Check if a STOMP appender for host:port exists in the factory. If not, create and register it
        // Such a check is not supported by cmw-log. Request.
        // In the meantime, rely on try-catch.
        CMW::Log::FilterLogger::Filters loggerFilters;
        loggerFilters.push_back("FESA.DIAG.FWK");
        loggerFilters.push_back("FESA.DIAG.USR");
        CMW::LogStomp::StompAppenderBuilder builder(appenderName);
        builder.setSocketType(socketType);
        builder.setHost(host);
        builder.setPort(port);
        builder.setDomain(domain);
        builder.setSubdomain(subDomain);
        builder.setSource(source);
        builder.setConnectionConfirmation(false);
        builder.addFilter(boost::shared_ptr<CMW::Log::FilterLogger>(new CMW::Log::FilterLogger(loggerFilters)));
        diagStompAppender = builder.build();
        try
        {
            CMW::Log::AppenderManager::registerAppender(diagStompAppender);
        }
        catch (CMW::Log::LogException& error)
        {
            LOG_ERROR_IF(logger, error.what());
        }
    }
    if (data.contains("fwkTopic"))
    {
        const int32_t fwkTopic = static_cast<int32_t>(data.extractInt("fwkTopic"));
        globalDevice.fwkTopic.set(fwkTopic, context);
        for (DiagnosticUtils::DiagnosticTopics::const_iterator iter = frameworkTopics.begin(); iter != frameworkTopics.end(); ++iter)
        {
            const int32_t mask = iter->first;
            const std::string topicName = iter->second;
            const bool enabled = fwkTopic & mask;
            if(logger.isLoggable(CMW::Log::Level::LL_TRACE))
            {
                std::ostringstream msg;
                msg << "fwkTopic: " << fwkTopic << "; mask: " << mask << "; topicName: " << topicName << "; enabled: " << enabled << "; loggerName: FESA.DIAG.FWK." << topicName;
                LOG_TRACE_IF(logger, msg.str());
            }
            if (enabled == true)
            {
                diagnostics->enable(DiagnosticUtils::framework, topicName);
            }
            else
            {
                diagnostics->disable(DiagnosticUtils::framework, topicName);
            }
        }
    }
    if (data.contains("customTopic"))
    {
        const int32_t customTopic = static_cast<int32_t>(data.extractInt("customTopic"));
        globalDevice.customTopic.set(customTopic, context);
        for (DiagnosticUtils::DiagnosticTopics::const_iterator iter = userTopics.begin(); iter != userTopics.end(); ++iter)
        {
            const int32_t mask = iter->first;
            const std::string topicName = iter->second;
            const bool enabled = customTopic & mask;
            if (logger.isLoggable(CMW::Log::Level::LL_TRACE))
            {
                std::ostringstream msg;
                msg << "customTopic: " << customTopic << "; mask: " << mask << "; topicName: " << topicName
                                << "; enabled: " << enabled << "; loggerName: FESA.DIAG.USR." << topicName;
                LOG_TRACE_IF(logger, msg.str());
            }
            if (enabled == true)
            {
                diagnostics->enable(DiagnosticUtils::user, topicName);
            }
            else
            {
                diagnostics->disable(DiagnosticUtils::user, topicName);
            }
        }
    }
    if (data.contains("traceDevices"))
    {
        const std::string traceDevices = data.getString("traceDevices");
        globalDevice.traceDevices.set(traceDevices.c_str(), context);
    }
    if (data.contains("bypassActions"))
    {
        const std::string bypassActions = data.getString("bypassActions");
        globalDevice.bypassActions.set(bypassActions.c_str(), context);
        std::vector<std::string> actions;
        CMW::Util::StringUtils::tokenize(bypassActions, actions, ",");
        std::vector<std::string>::const_iterator iter;
        for (iter = actions.begin(); iter < actions.end(); ++iter)
        {
            diagnostics->disable(DiagnosticUtils::framework, DiagnosticUtils::getActionProfilingStr + "." + *iter);
            diagnostics->disable(DiagnosticUtils::framework, DiagnosticUtils::setActionProfilingStr + "." + *iter);
            diagnostics->disable(DiagnosticUtils::framework, DiagnosticUtils::rtActionProfilingStr + "." + *iter);
            diagnostics->disable(DiagnosticUtils::framework, DiagnosticUtils::getActionTrackingStr + "." + *iter);
            diagnostics->disable(DiagnosticUtils::framework, DiagnosticUtils::setActionTrackingStr + "." + *iter);
            diagnostics->disable(DiagnosticUtils::framework, DiagnosticUtils::rtActionTrackingStr + "." + *iter);
        }
    }
    diagMsg.action = DiagnosticUtils::stop;
    diagnostics->log(serverActionTopic, diagMsg);
}

void SetDiagnosticSetting::performCommit(MultiplexingContext& context, AbstractDevice* device)
{
}

void SetDiagnosticSetting::performRollback(MultiplexingContext& context, AbstractDevice* transactionDevice)
{
}
} // fesa