MonitoringThread.h

Go to the documentation of this file.

// Copyright 2014 GSI, Inc. All rights reserved.
//
//
//

#ifndef __DDS__MonitoringThread__
#define __DDS__MonitoringThread__

// DDS
#include "Logger.h"
#include "Process.h"
// STL
#include <chrono>
#include <functional>
#include <mutex>
#include <thread>
// API
#include <csignal>

namespace dds
{
    class CMonitoringThread
    {
        typedef std::function<bool()> callbackFunction_t;
        // the function to call, the interval (in sec) the function should be called at
        typedef std::pair<callbackFunction_t, std::chrono::seconds> callbackValue_t;

      private:
        CMonitoringThread()
        {
        }
        ~CMonitoringThread()
        {
        }

      public:
        static CMonitoringThread& instance()
        {
            static CMonitoringThread instance;
            return instance;
        }

        void start(double _idleTime, const std::function<void(void)>& _idleCallback)
        {
            // Looping monitoring thread with a step of 1 sec up to *Unlimited* sec (size of int)
            static const std::chrono::seconds INTERVAL_STEP(1);
            static const std::chrono::seconds WAITING_TIME(20);

            updateIdle();

            std::thread t(
                [this, &_idleCallback, _idleTime]()
                {
                    try
                    {
                        std::chrono::seconds secInterval(0);
                        while (true)
                        {
                            // handle exceptions of the custom actions separately to prevent breaks of the
                            // monitoring thread
                            try
                            {
                                std::lock_guard<std::mutex> lock(m_registeredCallbackFunctionsMutex);
                                // Call registered callback functions
                                // We use Erase-remove idiom to execute callback and remove expired if needed.
                                m_registeredCallbackFunctions.erase(
                                    remove_if(m_registeredCallbackFunctions.begin(),
                                              m_registeredCallbackFunctions.end(),
                                              [&](callbackValue_t& i)
                                              {
                                                  // A callback function can return
                                                  // false, which
                                                  // means it wants to be unregistered
                                                  // (expire)
                                                  const int nCurInterval =
                                                      std::chrono::duration<int>(secInterval).count();
                                                  const int nInterval = std::chrono::duration<int>(i.second).count();
                                                  if (nCurInterval != 0 && nCurInterval >= nInterval &&
                                                      0 == (nCurInterval % nInterval))
                                                  {
                                                      LOG(dds::misc::debug)
                                                          << "MONITORING: calling callback at interval of "
                                                          << std::chrono::duration<int>(i.second).count();
                                                      return (!i.first());
                                                  }
                                                  return false;
                                              }),
                                    m_registeredCallbackFunctions.end());
                            }
                            catch (std::exception& _e)
                            {
                                LOG(dds::misc::error) << "MonitoringThread exception on custom actions: " << _e.what();
                            }
                            catch (...)
                            {
                                // Ignore any exception here to let the monitoring thread continue whatever it takes
                            }

                            std::chrono::seconds idleTime;
                            // Check if process is idle.
                            {
                                std::lock_guard<std::mutex> lock(m_mutex);
                                std::chrono::steady_clock::time_point currentTime = std::chrono::steady_clock::now();
                                idleTime =
                                    std::chrono::duration_cast<std::chrono::seconds>(currentTime - m_startIdleTime);
                            }

                            if (idleTime.count() > _idleTime)
                            {
                                // First call idle callback
                                LOG(dds::misc::info) << "The process is idle for " << idleTime.count()
                                                     << " sec. Call idle callback and wait "
                                                     << std::chrono::duration<int>(WAITING_TIME).count() << "s";
                                // handle exceptions of the custom idle callback separately to prevent breaks of the
                                // monitoring thread
                                try
                                {
                                    _idleCallback();
                                }
                                catch (std::exception& _e)
                                {
                                    LOG(dds::misc::error)
                                        << "MonitoringThread exception on custom idle function: " << _e.what();
                                }
                                catch (...)
                                {
                                    // Ignore any exception here to let the monitoring thread continue whatever it takes
                                }
                                std::this_thread::sleep_for(WAITING_TIME);

                                // Call terminate
                                LOG(dds::misc::info) << "Sending SIGTERM to this process...";
                                std::raise(SIGTERM);
                                std::this_thread::sleep_for(WAITING_TIME);

                                // Kill process
                                LOG(dds::misc::info) << "The process still exists. Killing the process...";
                                killProcess();
                            }

                            std::this_thread::sleep_for(INTERVAL_STEP);
                            secInterval += INTERVAL_STEP;
                        }
                    }
                    catch (std::exception& _e)
                    {
                        LOG(dds::misc::error) << "MonitoringThread exception: " << _e.what();
                    }
                });
            t.detach();
        }

        void updateIdle()
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            m_startIdleTime = std::chrono::steady_clock::now();
        }

        void registerCallbackFunction(callbackFunction_t _handler, const std::chrono::seconds& _interval)
        {
            std::lock_guard<std::mutex> lock(m_registeredCallbackFunctionsMutex);
            m_registeredCallbackFunctions.push_back(make_pair(_handler, _interval));
        }

      private:
        void killProcess()
        {
            pid_t pidToKill(::getpid());
            if (pidToKill > 0 && dds::misc::IsProcessRunning(pidToKill))
            {
                LOG(dds::misc::log_stdout) << " self exiting (" << pidToKill << ")...";
                // TODO: Maybe we need more validations of the process before
                // sending a signal. We don't want to kill someone else.
                kill(pidToKill, SIGTERM);

                // Waiting for the process to finish
                size_t iter(0);
                const size_t max_iter = 30;
                while (iter <= max_iter)
                {
                    if (!dds::misc::IsProcessRunning(pidToKill))
                    {
                        LOG(dds::misc::log_stdout) << std::endl;
                        break;
                    }
                    LOG(dds::misc::log_stdout) << ".";
                    sleep(1); // sleeping for 1 second
                    ++iter;
                }
                if (dds::misc::IsProcessRunning(pidToKill))
                {
                    LOG(dds::misc::error) << "FAILED to close the process.";
                    LOG(dds::misc::warning) << "Sending unconditional terminate to (" << pidToKill << ")...";
                    kill(pidToKill, SIGKILL);
                }
            }
        }

      private:
        std::chrono::steady_clock::time_point m_startIdleTime;

        std::function<void(void)> m_idleCallback;
        std::vector<callbackValue_t> m_registeredCallbackFunctions;

        std::mutex m_registeredCallbackFunctionsMutex;

        std::mutex m_mutex; // Mutex for updateIdle call
    };
} // namespace dds

#endif /* defined(__DDS__MonitoringThread__) */