QProcessStatus.cc

Go to the documentation of this file.

#include "QProcessStatus.hh"
 
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <iostream>
 
#include "QError.hh"
 
//________________________________________________________________________
QProcessStatus& QProcessStatus::GetInstance()
{
   static QProcessStatus instance;
   return instance;
}
 
 
//________________________________________________________________________
QProcessStatus::QProcessStatus():
   QNamed(""),
   QId(::getpid()),
   fState(QIdle_s),
   fPreviousState(QIdle_s),
   fTrgCtrl(false),
   fInformEnabled(false),
   kMaxQueued(4),
   fError("")
{
   fStatusQueue.clear();
   fSigMap.clear();
   return;
}
 
 
//_____________________________________________________________________________
void QProcessStatus::Disable(int signalId)
{
   fSigMap.erase(signalId);
   signal(signalId,SIG_DFL);
}
 
 
//_____________________________________________________________________________
bool QProcessStatus::Ignore(int signalId)
{
   if(signalId == SIGSEGV || signalId == SIGFPE)
      return false;
 
   fSigMap[signalId] = QIgnore_s;
   signal(signalId,SIG_IGN);
   return true;
}
 
 
//_____________________________________________________________________________
void QProcessStatus::Associate(int signalId, ProcessStatus_t pStatus)
{
   signal(signalId, SigHandler);
   if( (signalId == SIGFPE) || (signalId == SIGSEGV) )
     fSigMap[signalId] = QError_s;
   else
      fSigMap[signalId] = pStatus;
}
 
 
//_____________________________________________________________________________
void QProcessStatus::HandleSignal(int signalId)
{
   // reset error message
   SetError("");
   
   // get process status
   std::map<int,ProcessStatus_t>::const_iterator sigMapIt;
   if((sigMapIt = fSigMap.find(signalId)) == fSigMap.end()) 
   {
      std::cerr << "received unhandled signal " << signalId << std::endl;
      return;
   }
   const ProcessStatus_t newStatus = sigMapIt->second;
   const ProcessStatus_t lastStatus = GetLastStatus();
 
 
   // QError_s
   if(QError_s == newStatus)
   {
      // exit immediately if this is not the first detected error
      if(std::find(fStatusQueue.begin(),fStatusQueue.end(),
                   QError_s) != fStatusQueue.end())
      {
         std::cerr << "Unhandled critical Error: ";
         if(SIGSEGV == signalId)
            std::cerr << "Segmentation violation. ";
         if(SIGFPE == signalId)
            std::cerr << "Floating point exception. ";
         std::cerr << "Exit forced" << std::endl;
         exit(1);
      }
      
      if(signalId == SIGSEGV)
         SetError("Segmentation Fault detected");
      else if(signalId == SIGFPE)
         SetError("Floating Point Exception detected");
      
      AddToQueue(QError_s);
      return;
   }
   
   
   // QExiting_s
   else if(QExiting_s == newStatus)
   {
      AddToQueue(QExiting_s);
      return;
   }
   
   
   // QStopped_s
   else if(QStopped_s == newStatus) 
   {
      if (QRunning_s == lastStatus
          || QPaused_s  == lastStatus 
          || QWaiting_s == lastStatus )
         AddToQueue(QStopped_s);
      else
         SetError("Invalid state. Cannot STOP");
      
      return;
   }
      
   // QWaiting_s
   else if(QWaiting_s == newStatus) 
   {
      if (QReady_s  == lastStatus
          || QPaused_s == lastStatus )
         AddToQueue(QWaiting_s);
      else 
         SetError("Invalid state. Cannot START (in 'wait mode')");
      
      return;
   }
   
   // QRunning_s
   else if(QRunning_s == newStatus) 
   {
      if (QReady_s  == lastStatus
          || QPaused_s == lastStatus
          || QWaiting_s == lastStatus )
         AddToQueue(QRunning_s);
      else 
         SetError("Invalid state. Cannot START");
      
      return;
   }
   
 
   // QIdle_s
   else if(QIdle_s == newStatus)
   {
      AddToQueue(QIdle_s);
      return;
   }
   
 
   // QAskStatus_s
   else if(QAskStatus_s == newStatus)
   {
      InformServer();
      return;
   }
   
 
   // QTriggerOff_s
   else if(QTriggerOff_s == newStatus && TrgCtrlEnabled())
   {
      if (QRunning_s == lastStatus
          || QPaused_s == lastStatus
          || QWaiting_s == lastStatus )
         AddToQueue(QTriggerOff_s);
      else
         SetError("Cannot disable trigger if process is neither "
                         "running nor ready");
 
      return;
   }
   
 
   // QTriggerOn_s
   else if(QTriggerOn_s == newStatus && TrgCtrlEnabled())
   {
      if (QRunning_s == lastStatus
          || QPaused_s == lastStatus
          || QWaiting_s == lastStatus )
         AddToQueue(QTriggerOn_s);
      else
         SetError("Cannot re-enable trigger if process is neither "
                  "running nor ready");
   }
 
   // should never get here
   else
   {
      AddToQueue(QError_s);
      SetError("Unexpected signal or process status");
      std::cerr << "Error in signal handler: cannot handle signal "
                << signalId << std::endl;
   }
   return;
}
 
 
//_____________________________________________________________________________
void QProcessStatus::InformServer() 
{
   if(!fInformEnabled)
      return;
   QError err = QERR_SUCCESS;
   //QApolloMessenger& msg = QApolloMessenger::GetInstance();
   //err = msg.SendStatus(fState);
   if(err != QERR_SUCCESS)
      std::cout << err << std::endl;
   return;
}
 
 
//_____________________________________________________________________________
void QProcessStatus::SetState(ProcessStatus_t state)
{
   fPreviousState = fState;
   fState = state;
   fStatusQueue.clear();
   InformServer(); 
   std::cout << "set state called: old "
             << fPreviousState.AsString()
             << " new "
             << fState.AsString()
             << std::endl;
   return;
}
 
 
//________________________________________________________________________
void QProcessStatus::Notify()
{
   // cannot notify non-existent status
   if(fStatusQueue.empty())
      return;
 
   fPreviousState = fState;
   fState = fStatusQueue.front();
   fStatusQueue.pop_front();
   InformServer();
   return;
}
 
 
//________________________________________________________________________
void QProcessStatus::AddToQueue(ProcessStatus_t state)
{
   // in case trigger on/off status is added to queue, also last state
   // is added
   ProcessStatus_t last = GetLastStatus();
   fStatusQueue.push_back(state);
   if(QTriggerOn_s == state
      || QTriggerOff_s == state)
   {
      fStatusQueue.push_back(last);
   }
   if(fStatusQueue.size() > kMaxQueued)
   {
      std::cerr << "Warning: maximum process status queue size exceeded"
                << std::endl;
   }
}
 
 
//________________________________________________________________________
ProcessStatus_t QProcessStatus::GetLastStatus() const
{
   if(fStatusQueue.empty())
      return fState;
   return fStatusQueue.back();
}
 
 
//_____________________________________________________________________________
void SigHandler(int signalId)
{
   std::cout << "QProcessStatus: signal " << signalId << " ("
             << strsignal(signalId) << ") detected" << std::endl;
   QProcessStatus& status = QProcessStatus::GetInstance();
   status.HandleSignal(signalId);
}