ProcessSignalHandler.cpp

Go to the documentation of this file.

#include <signal.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <cassert>

#include "rms/provider/CETDDS.h"
#include "rms/provider/ProcessSignalHandler.h"

namespace gov {
namespace fnal {
namespace cd {
namespace rms {
namespace base
{
Notifiable::Notifiable():_beenNotified(false)
{

}

Notifiable::~Notifiable()
{

}

void  Notifiable::doNotify()
{
    doNotify_impl();
}

bool  Notifiable::hasBeenNotified() const
{
    return hasBeenNotified_impl();
}

void  Notifiable::doNotify_impl()
{
    boost::unique_lock<boost::mutex> guard(_lock);
    _beenNotified=true;
}

bool  Notifiable::hasBeenNotified_impl() const
{
    boost::unique_lock<boost::mutex> guard(_lock);
    return _beenNotified;
}

} // end of namespace base

namespace provider {
/*
 * Maintains a list of signal-number--signal-handler pairs;
 * signalhHandlerList is used by customSignalHandler
 */
ProcessSignalHandler::SignalHandlerPairList ProcessSignalHandler::_signalhHandlerList;

template <typename T>
bool equal(T * first,T * second)
{
    assert( first != NULL );
    assert( second != NULL );

    return first==second;
}

ProcessSignalHandler::ProcessSignalHandler()
        : _cleanupRequired( 1 )
{

}

/*
 * Adds Notifiable to the process exit notification list
 */
void ProcessSignalHandler::addToNotificationList( base::Notifiable* notifiable )
{
    boost::mutex::scoped_lock guard( _listLock );

   _notificationList.push_back( notifiable );
}

/*
 * Removes Notifiable to the process exit notification list
 */
void  ProcessSignalHandler::removeFromNotificationList(base::Notifiable* notifiable)
{
    boost::mutex::scoped_lock guard( _listLock );
  
   _notificationList.erase(std::remove_if(_notificationList.begin(),_notificationList.end(),
                                           boost::bind(equal<base::Notifiable>,notifiable,_1)),_notificationList.end());
}

/*
 * Replaces the default process signal handler by customSignalHandler
 * for a specified signal number
 */
bool ProcessSignalHandler::setupSignalHandler( int signalNumber )
{
    _signalhHandlerList.push_back( SignalHandlerPair( signalNumber,
                                   SignalHandler( boost::bind( &ProcessSignalHandler::processSignal, this, _1, this ) ) ) );
      
    struct sigaction action;
    action.sa_handler = &ProcessSignalHandler::customSignalHandler;
    sigemptyset( &action.sa_mask );
    action.sa_flags = 0;

    if ( sigaction( signalNumber, &action, &_previousSignalHandler ) == -1 )
      return false;     /*sigaction returned an error*/

    return true;
}

/*
 * Frees up resources on the DDS server upon receiving a process signal
 */
void ProcessSignalHandler::customSignalHandler( int signalNumber )
{
    SignalHandlerPairIterator end = _signalhHandlerList.end();

    //calls processSignal on a signal handler associated with the signal number
    for ( SignalHandlerPairIterator handler = ProcessSignalHandler::_signalhHandlerList.begin();
            handler != end;++handler ) {
        if ( handler->first == signalNumber )
            handler->second( signalNumber );
    }
}
/*
 * Acquires a unique lock for RmsLockable::sharedLock and calls performCleanup
 */
void ProcessSignalHandler::processSignal( int signalNumber, ProcessSignalHandler* handler )
{
    assert( handler != NULL );

#if CETDDS_DEBUG1
    std::cerr << "Processing signal (number=" << signalNumber << ")." << std::endl;
#endif
    boost::recursive_timed_mutex::scoped_lock guard( _selfLock,boost::get_system_time() + boost::posix_time::milliseconds(250) );

    if ( guard.owns_lock() && handler->_cleanupRequired)
    {
      handler->_cleanupRequired = 0;

      handler->closeDDSConnections();

      terminateDDSConnections();

    } else if(!guard.owns_lock())
    {
      #if CETDDS_DEBUG1
      std::cerr << "Termination in progress stalling thread." << std::endl;
      #endif

      boost::this_thread::sleep(boost::posix_time::milliseconds(5000));
    }else if (signalNumber==SIGSEGV)
    {
      std::cerr << "Warning: Program received signal SIGSEGV, Segmentation fault." << std::endl;
    }

    #if CETDDS_DEBUG1
    std::cout << "Finished processing signal (number=" << signalNumber << ")." << std::endl;
    #endif

    _exit(0);
}

/*
 * Gracefully closes DDS connections and frees up resources used by this client
 */
void ProcessSignalHandler::closeDDSConnections()
{
#if CETDDS_DEBUG1
    std::cout << "Notifying " << _notificationList.size() << " RMS connections to close." << std::endl;
#endif
    boost::mutex::scoped_lock guard( _listLock );

    DPSingleton::Instance().disconnect_participant();
 
    NotifiableListIterator end =  _notificationList.end();

    for ( NotifiableListIterator notifiable = _notificationList.begin();notifiable != end;++notifiable )
        (*notifiable )->doNotify(); /*notify DDS resources*/

}

/*
 *Terminates DDS connections prior exiting this process
 */
void ProcessSignalHandler::terminateDDSConnections()
{
  size_t activeConnectionCount=0;
   
  {
    boost::mutex::scoped_lock guard( _listLock );
    activeConnectionCount=_notificationList.size();
  }


    for (int retryCount=10; activeConnectionCount!=0 && retryCount>0;--retryCount)
    {
        usleep(50000);

        activeConnectionCount=0;
        
        boost::mutex::scoped_lock guard( _listLock );
        
        NotifiableListIterator end =  _notificationList.end();

        for ( NotifiableListIterator notifiable = _notificationList.begin();notifiable != end;++notifiable )
            if (!  (*notifiable )->hasBeenClosed())
                ++activeConnectionCount;
    }

    DDS::DomainParticipantFactory::get_instance()->delete_contained_entities();

    if(activeConnectionCount!=0)
    {
#if CETDDS_DEBUG1
      std::cout << "Terminating "<< activeConnectionCount << " RMS connections." << std::endl;
#endif
     
    boost::mutex::scoped_lock guard( _listLock );
    
    NotifiableListIterator end =  _notificationList.end();
    
    for ( NotifiableListIterator notifiable = _notificationList.begin();notifiable != end;++notifiable )
    {
        if (! (*notifiable )->hasBeenClosed())
            (*notifiable )->close(); /*notify DDS resources*/
    }
    }
}

void ProcessSignalHandlerDeleter::operator()( ProcessSignalHandler *handler )
{
    assert( handler != NULL );

#if CETDDS_DEBUG1
    std::cout << "Finished calling ProcessSignalHandlerDeleter." << std::endl;
#endif
}

SignalInhibitor::SignalInhibitor()
{
  sigset_t sigs;
  sigemptyset( &sigs );
  sigaddset( &sigs, SIGTERM );
  sigaddset( &sigs, SIGINT );
  sigaddset( &sigs, SIGSEGV );

  if ( pthread_sigmask( SIG_BLOCK, &sigs, 0 )) { 
    std::cout << "Unable to change signal mask in ctor" << std::endl;
  }
}

SignalInhibitor::~SignalInhibitor()
{
  sigset_t sigs;
  sigemptyset( &sigs );
  sigaddset( &sigs, SIGTERM );
  sigaddset( &sigs, SIGINT );
  sigaddset( &sigs, SIGSEGV );
  
  if ( pthread_sigmask( SIG_UNBLOCK, &sigs, 0 )) {
    std::cout << "Unable to change signal mask in dtor" << std::endl;
  }
}



}  // end of namespace provider


}  // end of namespace rms
}  // end of namespace cd
}  // end of namespace fnal
}  // end of namespace gov
// kate: indent-mode cstyle; space-indent on; indent-width 0;