Precommit (#1)

* first commit

* cleanup

tests/unit_tests/process_control/process_control_ifc.h

@@ -0,0 +1,91 @@
+#ifndef PROCESS_CONTROL_IFC_H
+#define PROCESS_CONTROL_IFC_H
+
+/**
+ * @brief Process control application parameters.
+ * @details The operating mode is the first parameter of the application.
+ */
+enum class EOperatingmode : uint32_t
+{
+    normal_shutdown_1000ms,         ///< Proper shutdown after 1000ms; exit code = 0
+    emergency_exit_1000ms,          ///< Emergency exit after 1000ms; exit code = -20
+    wait_for_process,               ///< Wait for process end; then shutdown; exit code = 0 on proper shutdown, -10 on emergency exit, -20 on timeout
+    terminate_process,              ///< Terminate the first process; then shutdown; exit code = 0
+};
+
+/**
+ * @brief Process monitor helper class
+ */
+class CProcessMonitorHelper : public sdv::IInterfaceAccess, public sdv::process::IProcessLifetimeCallback
+{
+public:
+    // Interface map
+    BEGIN_SDV_INTERFACE_MAP()
+        SDV_INTERFACE_ENTRY(sdv::process::IProcessLifetimeCallback)
+    END_SDV_INTERFACE_MAP()
+
+    /**
+     * @brief Called when the process was terminated. Overload of sdv::process::IProcessLifetimeCallback::ProcessTerminated.
+     * @remarks The process return value is not always valid. The validity depends on the support of the underlying system.
+     * @param[in] tProcessID The process ID of the process being terminated.
+     * @param[in] iRetValue Process return value or 0 when not supported.
+     */
+    virtual void ProcessTerminated(/*in*/ sdv::process::TProcessID tProcessID, /*in*/ int64_t iRetValue) override
+    {
+        std::unique_lock<std::mutex> lock(m_mtxTerminate);
+        m_tProcessID = tProcessID;
+        m_iRetValue = iRetValue;
+        m_bCalled = true;
+        lock.unlock();
+        m_cvTerminate.notify_all();
+    }
+
+    /**
+     * @brief Wait for 5000ms for the process to terminate.
+     * @return Returns 'true' on successful terminate; 'false' due to a timeout.
+     */
+    bool Wait5000ms()
+    {
+        std::unique_lock<std::mutex> lock(m_mtxTerminate);
+        std::chrono::high_resolution_clock::time_point tpStart = std::chrono::high_resolution_clock::now();
+        while (!m_bCalled && std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - tpStart).count() < 5.0)
+        {
+            m_cvTerminate.wait_for(lock, std::chrono::milliseconds(30));
+        }
+        std::cout << GetTimestamp() << "Process PID#" << std::dec << m_tProcessID << " has " << (m_bCalled ? "" : "not ") << "terminated." << std::endl;
+        return m_bCalled;
+    }
+
+    /**
+     * @brief Get the process ID (to be called after successful termination).
+     * @return The process ID provided by the callback event.
+     */
+    sdv::process::TProcessID GetProcessID() const
+    {
+        std::unique_lock<std::mutex> lock(m_mtxTerminate);
+        return m_tProcessID;
+    }
+
+    /**
+     * @brief Get the return value (to be called after successful termination).
+     * @return The return value provided by the callback event.
+     */
+    int64_t GetRetValue() const
+    {
+        std::unique_lock<std::mutex> lock(m_mtxTerminate);
+        return m_iRetValue;
+    }
+
+private:
+    mutable std::mutex          m_mtxTerminate;         ///< Mutex for process termination conditional variable.
+    std::condition_variable     m_cvTerminate;          ///< Process termination conditional variable.
+    sdv::process::TProcessID    m_tProcessID = 0;       ///< Process ID of terminated process.
+    int64_t                     m_iRetValue = -100;     ///< Process return value.
+    bool                        m_bCalled = false;      ///< Set when called (to prevent waiting for condition var).
+};
+
+
+
+
+
+#endif // !defined PROCESS_CONTROL_IFC_H