WatchdogThread.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#ifndef GAUDIKERNEL_WATCHDOGTHREAD_H_
#define GAUDIKERNEL_WATCHDOGTHREAD_H_
 
#include <memory>
#include <mutex>
 
#include "boost/date_time/posix_time/posix_time_types.hpp"
#include "boost/thread/thread_time.hpp"
 
// for GAUDI_API
#include "GaudiKernel/Kernel.h"
 
// forward declaration
namespace boost {
  class thread;
}
 
class GAUDI_API WatchdogThread {
public:
  //  @param timeout the time span that can occur between two pings.
  //  @param autostart if set to true, the second thread is started automatically
  //                   on construction, otherwise the user have to call start().
  WatchdogThread( boost::posix_time::time_duration timeout, bool autostart = false );
 
  //  Stop the thread of not done earlier.
  virtual ~WatchdogThread();
 
  void start();
 
  void stop();
 
  inline void ping() {
    auto lock  = std::scoped_lock{ m_lastPingMutex };
    m_lastPing = boost::get_system_time();
    onPing();
  }
 
  inline void setTimeout( boost::posix_time::time_duration timeout ) { m_timeout = timeout; }
 
  inline boost::posix_time::time_duration getTimeout() const { return m_timeout; }
 
  inline boost::system_time getLastPing() const {
    auto lock = std::scoped_lock{ m_lastPingMutex };
    return m_lastPing;
  }
 
protected:
  virtual void action();
 
  virtual void onPing();
 
  virtual void onStart();
 
  virtual void onStop();
 
private:
  boost::posix_time::time_duration m_timeout;
 
  boost::system_time m_lastPing;
 
  std::unique_ptr<boost::thread> m_thread;
 
  bool m_running;
 
  //  Waits for the time-out and if there was not a ping in the mean time, calls
  //  i_action().
  void i_run();
 
  mutable std::mutex m_lastPingMutex;
};
 
#endif /* WATCHDOGTHREAD_H_ */