AbstractServerEquipment.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

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

#include <fesa-core/Server/AbstractServerController.h>
#include <fesa-core/Server/AbstractServerAction.h>
#include <fesa-core/Server/AbstractServerDeviceClass.h>
#include <fesa-core/RDADeviceServer/SubscriptionTreeManager.h>
#include <fesa-core/RDADeviceServer/FesaDeviceServer.h>
#include <fesa-core/DataStore/EquipmentData.h>
#include <fesa-core/DataStore/AbstractDeviceFactory.h>
#include <fesa-core/DataStore/GlobalDevice.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <fesa-core/Utilities/ProcessConfiguration.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.Server.AbstractServerEquipment");
const std::string diagTopic = fesa::DiagnosticUtils::rdaTrackingStr;

} // namespace


namespace fesa
{

AbstractServerEquipment* AbstractServerEquipment::theInstance_ = NULL;


AbstractServerEquipment::AbstractServerEquipment()
{
    const ProcessConfiguration* configuration = AbstractEquipment::getInstance()->getProcessConfiguration();
    bool useFastUpdate = (configuration->getStringValue(PropertyTag::CLIENT_UPDATE_POLICY) == "fast") ? true : false;
    pSubscriptionTreeManager_ = new SubscriptionTreeManager(useFastUpdate);
    theInstance_ = this;
    // Initialize RDA and instantiate the server. This needs to be done at this time due to some RDA constraints.
    // Briefly:  in case of Server and RDA client running inside the same process the rdaConfigfile (specified by the server)
    // should be set before a RDA Client executes any rdaRDAService::init().
    // This is accomplished in the deployUnitMixed.cpp.xsl, which generates first the initialization of the server.
    const std::string rdaServerName = getServerNameFromConfigurationFile();
    FesaDeviceServer::initCMW();
    pFesaDeviceServer_ = new FesaDeviceServer(rdaServerName, configuration, pSubscriptionTreeManager_);
    pServerController_ = new AbstractServerController(*pSubscriptionTreeManager_);
}


void AbstractServerEquipment::initialize()
{
    EquipmentData* eqData = EquipmentData::getInstance();
    *(eqData->serverUp_) = false;

    // set  processID
    if (*(eqData->serverProcessID_ )!= 0) // There is already a Server process registered
    {
        // is the other process up?
        if(kill(*(eqData->serverProcessID_), SIGFESA_CHECK_PROCESS_ALIVE) == 0) // if the signal is successfully sent means that the process is up and running
        {
            // then abort the current process
            throw FesaException(__FILE__, __LINE__, FesaErrorServerProcessAlreadyExists.c_str());
        }
        else
        {
            if (errno != ESRCH)  // errno = ESRCH means that the process is not running
            {
                // If the error is different that ESRCH (i.e. no rights to send signal) we should abort
                throw FesaException(__FILE__, __LINE__, FesaErrorNoPermissionToSendSignals.c_str());
            }
        }
    }
    *(eqData->serverProcessID_) = getpid();

    AbstractComponentEquipment::initialize();
    pServerController_->initialize();

    //Initialization ends :time to dump the configuration
}


void AbstractServerEquipment::start(RunMode runMode)
{
    pServerController_->start();

    // start the RDA device server
    pFesaDeviceServer_->start();

    // signal that the server part is ready
    *(EquipmentData::getInstance()->serverUp_) = true;

    if ( runMode == blocking )
    {
        waitSignal();
    }
}


AbstractServerEquipment::~AbstractServerEquipment()
{
    LOG_DEBUG_IF(logger, "Shutting down RDA interface ");

    FesaDeviceServer::shutDown();
    if (pFesaDeviceServer_ !=NULL)
    {
        delete(pFesaDeviceServer_);
    }

    // remove static data in the AbstractServerAction
    AbstractServerAction::releaseStaticObjects();
    if (pServerController_ != NULL)
    {
        delete pServerController_;
        pServerController_ = NULL;
    }

    LOG_DEBUG_IF(logger, "Server equipment removed ");

}


AbstractServerDeviceClass* AbstractServerEquipment::getDeviceClassFromDeviceName(const std::string& devicename)
{
    std::vector<AbstractDeviceClass*>::iterator iter = abstractDeviceClassCol_.begin();
    std::vector<AbstractDeviceClass*>::iterator end = abstractDeviceClassCol_.end();

    for (; iter != end; ++iter)
    {
        try
        {
            AbstractDeviceFactory* factory = (*iter)->getDeviceFactory();
            // check that the factory contains the device either as a global or as a normal one
            if (factory->getDevice(devicename) != NULL)
            {
                return static_cast<AbstractServerDeviceClass*> (*iter);
            }
            else if((factory->getGlobalDevice() != 0 ) && (factory->getGlobalDevice()->getName() == devicename))
            {
                return static_cast<AbstractServerDeviceClass*> (*iter);
            }
        }
        catch (FesaException& ex)
        {
            if (ex.getErrorCode() != FesaErrorUnknownDevice)
                throw ex;
            //otherwise just continue the search
        }
    }
    //if not found
    throw FesaException(__FILE__, __LINE__, FesaErrorUnknownDevice.c_str(), devicename.c_str());
}


void AbstractServerEquipment::reportErrorToAllSubscribers(std::string Message)
{
    AbstractEquipment* eqp = AbstractEquipment::getInstance();
    const std::vector<AbstractDeviceClass*>& classCol = eqp->getServerComponent()->getDeviceClassCol();

    std::vector<AbstractDeviceClass*>::const_iterator iter;
    for (iter = classCol.begin(); iter != classCol.end(); iter++)
    {
        (static_cast<AbstractServerDeviceClass*> (*iter))->reportErrorToSubscribers(Message);
    }
}


AbstractServerController* AbstractServerEquipment::getServerController()
{
    return pServerController_;
}


void AbstractServerEquipment::waitSignal()
{
    sigset_t sigset;
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGTSTP);
    pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);

    sigemptyset(&sigset);
    sigaddset(&sigset, SIGHUP);
    sigaddset(&sigset, SIGINT);
    sigaddset(&sigset, SIGQUIT);
    sigaddset(&sigset, SIGILL);
    sigaddset(&sigset, SIGTRAP);
    sigaddset(&sigset, SIGABRT);
    sigaddset(&sigset, SIGBUS);
    sigaddset(&sigset, SIGFPE);
    sigaddset(&sigset, SIGSEGV);
    sigaddset(&sigset, SIGTERM);
    sigaddset(&sigset, SIGSTKFLT);
    sigaddset(&sigset, SIGSTOP);
    sigaddset(&sigset, SIGTTIN);
    sigaddset(&sigset, SIGTTOU);
    sigaddset(&sigset, SIGFESA_RT_DOWN);
    sigaddset(&sigset, SIGFESA_NOTIFICATION_FAILURE);
    sigaddset(&sigset, SIGFESA_CHECK_PROCESS_ALIVE);

    int32_t signalID;
    for (;;)
    {
        sigwait(&sigset, &signalID);

        if(signalID == SIGFESA_CHECK_PROCESS_ALIVE)
        {
            continue; // If the signal was just to check if process alive, nothing to be done
        }

        // User signal used by RT to indicate the termination of the RT process
        // Switch cannot be used because SIGFESA_RT_DOWN and SIGFESA_NOTIFICATION_FAILURE are not constant-expression
        if(signalID == SIGFESA_RT_DOWN)
        {
            std::string errorStr("Server process received signal from RT: RT is going down.");
            LOG_WARNING_IF(logger, errorStr);
            pSubscriptionTreeManager_->reportInternalError(std::string("FesaInternalError"), -signalID, std::string("RealTime process is missing."));
            //skip the rest
            continue;
        }
        // User signal used by RT to indicate notification queue full
        if(signalID == SIGFESA_NOTIFICATION_FAILURE)
        {
            std::string errorStr("Server process received signal from RT: Notification queue is full.");
            LOG_WARNING_IF(logger, errorStr);
            pSubscriptionTreeManager_->reportInternalError(std::string("FesaInternalError"), -signalID, std::string("Notification failure (queue is full)."));
            //skip the rest
            continue;
        }
        // Otherwise the signal is fatal and the shutdown procedure should be called
        EquipmentData* eqData = EquipmentData::getInstance();
        *(eqData->serverUp_) = false;
        std::string errorStr("Fatal signal received, shutting down Server process.");
        LOG_WARNING_IF(logger, errorStr);

        // TODO Should we call any shutdown (specificShutdown....)?

        // We call the default action of the fatal signal, this will let us to create the core dump files
        pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);
        signal(signalID, SIG_DFL);
        raise(signalID);
    }
    return;
}


const std::string AbstractServerEquipment::getServerNameFromConfigurationFile()
{
    const ProcessConfiguration* configuration = AbstractEquipment::getInstance()->getProcessConfiguration();
    std::string rdaServerName(configuration->getCMWServerName());
    if (rdaServerName.empty() == false)
    {
        const boost::shared_ptr<Diagnostics>& diagnostics = AbstractEquipment::getInstance()->getDiagnostics();
        DiagnosticUtils::DiagnosticMessage diagMsg;
        diagMsg.side = DiagnosticUtils::framework;
        diagMsg.source = DiagnosticUtils::server;
        std::ostringstream traceStrStream;
        traceStrStream << "Forcing RDADeviceServer name to '" << rdaServerName << "'";
        diagMsg.msg = traceStrStream.str();
        diagnostics->log(diagTopic, diagMsg);
    }
    else
    {
        rdaServerName += AbstractEquipment::getInstance()->getEquipmentName();
        rdaServerName += ".";
        rdaServerName += AbstractEquipment::getInstance()->getHostName();
    }
    return rdaServerName;
}

} // fesa