Invoke optional callback function on timer expiration

When the timer expires, it calls into it's own timeout
handler which matches with sd_event callback handler.

However, it is beneficial if the users of timer register
their own callback routine so that they can execute some
operations on timeout.

Change-Id: Ia88cb4e3c17f6dd8d4528fa193ec7927f083a92b
Signed-off-by: Vishwanatha Subbanna <vishwa@linux.vnet.ibm.com>

4 files changed, 31 insertions, 9 deletions

diff --git a/timer.cpp b/timer.cpp
index bf1a470..c98dcb0 100644
--- a/timer.cpp
+++ b/timer.cpp
@@ -44,12 +44,16 @@ int Timer::timeoutHandler(sd_event_source* eventSource,
 {
     using namespace phosphor::logging;
 
+    log<level::INFO>("Timer Expired");
+
     auto timer = static_cast<Timer*>(userData);
     timer->expire = true;
 
-    log<level::INFO>("Timer Expired");
-
-    //TODO: Need to call user callback function.
+    // Call an optional callback function
+    if(timer->userCallBack)
+    {
+        timer->userCallBack();
+    }
     return 0;
 }
 
diff --git a/timer.hpp b/timer.hpp
index 49580d7..2ade017 100644
--- a/timer.hpp
+++ b/timer.hpp
@@ -43,10 +43,14 @@ class Timer
 
         /** @brief Constructs timer object
          *
-         *  @param[in] event - sd_event unique pointer reference
+         *  @param[in] event        - sd_event unique pointer
+         *  @param[in] userCallBack - Optional function callback
+         *                            for timer expiration
          */
-        Timer(EventPtr& event)
-            : event(event)
+        Timer(EventPtr& event,
+              std::function<void()> userCallBack = nullptr)
+            : event(event),
+              userCallBack(userCallBack)
         {
             // Initialize the timer
             initialize();
@@ -100,6 +104,11 @@ class Timer
         /** @brief Set to true when the timeoutHandler is called into */
         bool expire = false;
 
+        /** @brief Optional function to call on timer expiration
+         *         This is called from timeout handler.
+         */
+        std::function<void()> userCallBack;
+
         /** @brief Initializes the timer object with infinite
          *         expiration time and sets up the callback handler
          *
diff --git a/watchdog.cpp b/watchdog.cpp
index c9e9919..e5e8aff 100644
--- a/watchdog.cpp
+++ b/watchdog.cpp
@@ -1,7 +1,6 @@
 #include <chrono>
 #include <phosphor-logging/log.hpp>
 #include "watchdog.hpp"
-
 namespace phosphor
 {
 namespace watchdog
@@ -92,5 +91,13 @@ uint64_t Watchdog::timeRemaining(uint64_t value)
     return 0;
 }
 
+// Optional callback function on timer expiration
+void Watchdog::timeOutHandler()
+{
+    log<level::INFO>("Optional callback called");
+    // TODO: Need to call the user passed systemd
+    // target on this condition
+}
+
 } // namespace watchdog
 } // namepsace phosphor
diff --git a/watchdog.hpp b/watchdog.hpp
index 47484af..1a7a410 100644
--- a/watchdog.hpp
+++ b/watchdog.hpp
@@ -5,7 +5,6 @@
 #include <sdbusplus/server/object.hpp>
 #include <xyz/openbmc_project/State/Watchdog/server.hpp>
 #include "timer.hpp"
-
 namespace phosphor
 {
 namespace watchdog
@@ -39,7 +38,7 @@ class Watchdog : public WatchdogInherits
                 EventPtr& event) :
             WatchdogInherits(bus, objPath),
             bus(bus),
-            timer(event)
+            timer(event, std::bind(&Watchdog::timeOutHandler, this))
         {
             // Nothing
         }
@@ -86,6 +85,9 @@ class Watchdog : public WatchdogInherits
 
         /** @brief Contained timer object */
         Timer timer;
+
+        /** @brief Optional Callback handler on timer expirartion */
+        void timeOutHandler();
 };
 
 } // namespace watchdog