AbstractRTEquipment.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/RealTime/AbstractRTEquipment.h>
#include <fesa-core/RealTime/AbstractRTDeviceClass.h>
#include <fesa-core/Diagnostic/FesaStream.h>
#include <fesa-core/DataStore/EquipmentData.h>
#include <fesa-core/RealTime/RTScheduler.h>
#include <fesa-core/RealTime/RTController.h>
#include <fesa-core/Core/AbstractEquipment.h>
#include <pthread.h>

#include <cmw-log/Logger.h>


namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.RealTime.AbstractRTEquipment");

} // namespace


namespace fesa
{

//init static members
AbstractRTEquipment* AbstractRTEquipment::theInstance_ = NULL;

AbstractRTEquipment::AbstractRTEquipment()

{

        theInstance_ = this;
        rtController_ = new RTController();
}

void AbstractRTEquipment::initialize()
{
        EquipmentData* eqData = EquipmentData::getInstance();
        *(eqData->rtUp_) = false;
        // set  processID
        if (*(eqData->rtProcessID_) != 0) // There is already a RT process registered
        {
                // is the other process up?
                if(kill(*(eqData->rtProcessID_), 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__, FesaErrorRTProcessAlreadyExists.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->rtProcessID_) = getpid();

        //trigger initialize the classes
        AbstractComponentEquipment::initialize();
        rtController_->initialize();
}

void AbstractRTEquipment::start(RunMode runMode)
{
    // DIAGNOSTIC: Update configuration file to describe Event-sources & Scheduling
        AbstractEquipment* pEqp = AbstractEquipment::getInstance();
        std::string equipmentName = pEqp->getEquipmentName();
        FesaStream* configStream = FesaStream::getConfigStream(equipmentName + "Rt");

        *configStream << " fesa-version=\"" <<  pEqp->getFesaVersion() << "\" deploy-type=\"" << pEqp->getProcessTypeAsString() << "\" fesa-compilation-DT=\"" << pEqp->getFesaBuildDate() << "\">" << std::endl;
        *configStream << "\t<equipment-real-time class-name=\"\"  class-version=\"\"" << std::endl;

        rtController_->printConfigAll(configStream);
        configStream->update();
        delete configStream;

        rtController_->start();

        // specify that the RT part is ready
        *(EquipmentData::getInstance()->rtUp_) = true;

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

AbstractRTEquipment::~AbstractRTEquipment()
{
        if (rtController_ != NULL)
        {
                delete rtController_;
                rtController_ = NULL;
        }

        theInstance_ = NULL;
}

void AbstractRTEquipment::printConfigAll(FesaStream* fesaStream)
{
        rtController_->printConfigAll(fesaStream);
}
void AbstractRTEquipment::printStateAll(FesaStream* fesaStream, double elapsedTime)
{
        rtController_->printStateAll(fesaStream, elapsedTime);
}

void AbstractRTEquipment::waitSignal()
{
//         fesa::FesaLogger* log = fesa::FesaLogger::getDefaultLogger();

        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_CHECK_PROCESS_ALIVE);

        int32_t signalID;
        for (;;)
        {
                // Wait for any fatal signal
                sigwait(&sigset, &signalID);

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

                // Inform server part about fatal signal
                EquipmentData* equipmentData = EquipmentData::getInstance();
                kill(*(equipmentData->srvProcessPid_), SIGFESA_RT_DOWN);

                *(equipmentData->rtUp_) = false;

//             log->logError(fesa::FesaLogger::warning) << "Fatal signal received, shutting down RT process. Informing Server process if any." << std::endl;
                std::string errorStr("Fatal signal received, shutting down RT process. Informing Server process if any.");
                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;
}

void AbstractRTEquipment::fillRTSchedulerInfo(std::vector<RTLayerInfo*>& layerCol)
{

        RTLayerInfo* layer = new RTLayerInfo();

        layer->layerName_ = DIAGNOSTIC_LAYER;
        layer->queueSize_ = -1;

        RTSchedulingUnitRef schedulingUnit;
        schedulingUnit.className_ = AbstractEquipment::getInstance()->getEquipmentName();
        schedulingUnit.name_ = "diagnosticLayer";
        schedulingUnit.perDeviceCollection_ = false;
        schedulingUnit.found_ = false;
        layer->schedulingUnitRefCol_.push_back(schedulingUnit);

        layerCol.push_back(layer);
}

void RTLayerInfo::print()
{
    if (logger.isLoggable(CMW::Log::Level::LL_DEBUG))
    {
        std::ostringstream msg;
        msg << " layerName_: " << layerName_ << " queueSize_: " << queueSize_;
        LOG_DEBUG_IF(logger, msg.str());
    }
}

}// end namespace