NotificationIDManager.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Core/NotificationIDManager.h>

#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Core/NotificationID.h>
#include <fesa-core/DataStore/EquipmentData.h>
#include <fesa-core/Utilities/XMLParser.h>
#include <fesa-core/Utilities/StringUtilities.h>
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/Diagnostic/Diagnostics.h>

#include <cmw-log/Logger.h>


namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.Core.NotificationIDManager");
const std::string diagTopic = fesa::DiagnosticUtils::notificationProfilingStr;

} // namespace


namespace fesa
{

NotificationIDManager* NotificationIDManager::theInstance_ = NULL;

NotificationIDManager::NotificationIDManager()
{
}

NotificationIDManager::~NotificationIDManager()
{
}

NotificationIDManager* NotificationIDManager::getInstance()
{
    if (theInstance_ == NULL)
    {
        theInstance_ = new NotificationIDManager();
    }
    return theInstance_;
}

void NotificationIDManager::releaseInstance()
{
    if (theInstance_ != NULL)
    {
        delete theInstance_;
        theInstance_ = NULL;
    }
}

void NotificationIDManager::save()
{
    if (AbstractEquipment::getInstance()->getProcessType() == unsplit)
    {
        return;
    }
    const boost::shared_ptr<Diagnostics>& diagnostics = AbstractEquipment::getInstance()->getDiagnostics();
    DiagnosticUtils::DiagnosticMessage diagMsg;
    diagMsg.side = DiagnosticUtils::framework;
    diagMsg.source = DiagnosticUtils::notification;
    diagMsg.name = "NotificationIDManager";
    diagMsg.msg = "Will save notification ID collection to file (RT side)";
    diagnostics->log(diagTopic, diagMsg);
    // store the notifications into a file
    storeNotificationIDCollection();
    /* Set notificationIDreadoutFlag to permit read out from server side */
    EquipmentData* equipmentData = EquipmentData::getInstance();
    *(equipmentData->notificationIDreadoutFlag_) = true;
    diagMsg.msg = "Saved notification ID collection to file";
    diagnostics->log(diagTopic, diagMsg);
}

void NotificationIDManager::storeNotificationIDCollection()
{
    XMLParser parser(AbstractEquipment::getInstance()->getNotificationFileName(), false);

    parser.createFile();
    parser.startDocument();

    parser.startElement(NOTIFICATION_ID_COLLECTION_TAG);
    parser.writeNewline();

    for (std::map<uint32_t, NotificationID*>::iterator notification = notificationIDCol_.begin(); notification
             != notificationIDCol_.end(); notification++)
    {
        parser.startElement("NotificationID");
        parser.writeNewline();
        parser.writeElement("idkey", StringUtilities::toString((*notification).second->getIDKey()));
        parser.writeNewline();
        parser.writeElement("classname", (*notification).second->getClassName());
        parser.writeNewline();

        const std::set<std::string>& PropCol = (*notification).second->getPropertyCol();
        for (std::set<std::string>::iterator stringIter = PropCol.begin(); stringIter != PropCol.end(); stringIter++)
        {
            parser.writeElement("property", *stringIter);
            parser.writeNewline();
        }
        const std::set<std::string>& DevCol = (*notification).second->getDeviceCol();
        for (std::set<std::string>::iterator stringIter = DevCol.begin(); stringIter != DevCol.end(); stringIter++)
        {
            parser.writeElement("device", *stringIter);
            parser.writeNewline();
        }
        parser.endElement();
        parser.writeNewline();
    }
    parser.endElement();
    parser.writeNewline();
    parser.endDocument();
}

void NotificationIDManager::load()
{
    const boost::shared_ptr<Diagnostics>& diagnostics = AbstractEquipment::getInstance()->getDiagnostics();
    DiagnosticUtils::DiagnosticMessage diagMsg;
    diagMsg.side = DiagnosticUtils::framework;
    diagMsg.source = DiagnosticUtils::notification;
    diagMsg.name = "NotificationIDManager";
    diagMsg.msg = "Will load notification ID collection from file (server side)";
    diagnostics->log(diagTopic, diagMsg);
    AbstractEquipment* eqp = AbstractEquipment::getInstance();
    // Reading fails if one of the classes does not have the flag
    EquipmentData* equipmentData = EquipmentData::getInstance();
    if (*(equipmentData->notificationIDreadoutFlag_) == false)
    {
        diagMsg.msg = "Failed loading notification ID collection from file";
        diagnostics->log(diagTopic, diagMsg);
        // TODO: if the Exception is not consistent with the definition in terms of variable arguments there is a seg fault
        // temporary fix by adding "unknown"
        throw FesaException(__FILE__, __LINE__, FesaErrorLoadNotificationIDCollection.c_str(), "Unknown");


    }

    // If all flags are set, start the read out
    try
    {
        loadNotificationIDCollection();
    }
    catch (FesaException& ex)
    {
        std::ostringstream traceStrStream;
        traceStrStream << "Failed loading notification ID collection from file, file not found."
                       << "Either file '" << eqp->getNotificationFileName()
                       << "' has been removed accidently or RT-side is not ready yet";
        diagMsg.msg = traceStrStream.str();
        diagnostics->log(diagTopic, diagMsg);
        throw;
    }
    diagMsg.msg = "Loaded notification ID collection from file";
    diagnostics->log(diagTopic, diagMsg);
}

const std::map<uint32_t, NotificationID*>& NotificationIDManager::getNotificationIDCol()
{
    FesaProcessType processType = AbstractEquipment::getInstance()->getProcessType();
    if (processType == unsplit || processType == splitServerOnly || processType == splitRealTimeOnly)
    {
        return notificationIDCol_;
    }
    else
    {
        load();
        return notificationIDCol_;
    }
}

void NotificationIDManager::loadNotificationIDCollection()
{
    std::string fileName = AbstractEquipment::getInstance()->getNotificationFileName();

    XMLParser parser(fileName, true);

    uint32_t tempKey;
    bool error = false;

    std::vector<ElementXML*>* pElCol = parser.extractElements("NotificationID");

    if (pElCol == NULL)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorLoadNotificationIDCollection.c_str(), fileName.c_str());
    }

    //for each NotificationID
    for (std::vector<ElementXML*>::iterator iter = pElCol->begin(); iter != pElCol->end(); iter++)
    {
        std::string className;
        std::set<std::string> properties;
        std::set<std::string> devices;

        //for each child
        for (std::vector<ElementXML*>::iterator iter2 = (*iter)->childList_.begin(); iter2
                 != (*iter)->childList_.end(); iter2++)
        {
            if ((*iter2)->name_ == "idkey")
            {
                StringUtilities::fromString(tempKey, (*iter2)->value_);
            }
            else if ((*iter2)->name_ == "classname")
            {
                className = (*iter2)->value_;
            }
            else if ((*iter2)->name_ == "property")
            {
                properties.insert((*iter2)->value_);
            }
            else if ((*iter2)->name_ == "device")
            {
                devices.insert((*iter2)->value_);
            }
            else
            {
                error = true;
                break;
            }
        }//end for each attribute

        NotificationID* tempID = new NotificationID(tempKey, className, devices, properties);
        notificationIDCol_.insert(std::pair<uint32_t, NotificationID*>(tempKey, tempID));
    }//end for Each NotificationID

    if (pElCol != NULL)
    {
        for (std::vector<ElementXML*>::iterator iter = pElCol->begin(); iter != pElCol->end(); iter++)
        {
            delete (*iter);
        }
        delete pElCol;
    }

    if (error)
    {
        throw FesaException(__FILE__, __LINE__, FesaErrorLoadNotificationIDCollection.c_str(), fileName.c_str());
    }
}

uint32_t NotificationIDManager::createNotificationID(const std::set<std::string>& notifiedProperties,
                                                         const std::set<std::string>& deviceNames, const std::string& classname)
{
    //check, if the ID already exists
    std::map<uint32_t, NotificationID*>::iterator iter;
    for (iter = notificationIDCol_.begin(); iter != notificationIDCol_.end(); iter++)
    {
        if ((*iter).second->getClassName() == classname)
        {
            if ((*iter).second->getDeviceCol() == deviceNames && (*iter).second->getPropertyCol()
                == notifiedProperties)
            {
                return (*iter).first;
            }
        }
    }

    // 0 means noID, therefore 1 is added to the size of the notification collections size
    NotificationID *pID = new NotificationID(static_cast<uint32_t>(notificationIDCol_.size()) + 1, classname, deviceNames,
                                             notifiedProperties);

    notificationIDCol_.insert(std::pair<uint32_t, NotificationID*>(pID->getIDKey(), pID));
    return pID->getIDKey();
}

} // fesa