iox-#2330 add notify systemd

.github/workflows/build-test.yml

@@ -204,6 +204,22 @@ jobs:
         uses: ./.github/actions/install-iceoryx-deps-and-clang
       - run: ./tools/ci/build-test-ubuntu-bazel.sh
 
+  # Check run systemd
+  build-and-run-roudi-with-systemd-and-build-test-and-run-ubuntu:
+    # prevent stuck jobs consuming runners for 6 hours
+    timeout-minutes: 60
+    runs-on: ubuntu-latest
+    needs: pre-flight-check
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install iceoryx dependencies and clang-tidy
+        uses: ./.github/actions/install-iceoryx-deps-and-clang
+      - name: Build project and test and run unit test
+        run: sudo ./tools/ci/build-test-ubuntu-support-systemd-unit.sh
+      - name: Run integration test
+        run: sudo ./tools/ci/build-test-ubuntu-support-systemd-integrations.sh
+
   coverage-and-docs:
     # prevent stuck jobs consuming runners for 6 hours
     timeout-minutes: 60

doc/website/getting-started/installation.md

@@ -184,6 +184,32 @@ The `CMakeLists.txt` from `iceoryx_meta` can be used to easily develop iceoryx w
 Please take a look at the CMake file [build_options.cmake](../../../iceoryx_meta/build_options.cmake)
 to get an overview of the available build options for enabling additional features.
 
+If systemd support is enabled `-DUSE_SYSTEMD=ON`, the unit file may look like this:
+
+````bash
+#$ vim /usr/lib/systemd/system/test_iceoryx.service
+[Unit]
+Description=Test application roudi
+
+[Service]
+Type=notify
+User=roma
+RestartSec=10
+Restart=always
+ExecStart=/usr/bin/iox-roudi
+TimeoutStartSec=10
+WatchdogSec=5
+
+[Install]
+WantedBy=multi-user.target
+
+````
+Do not forget to do this after adding the unit file `systemctl daemon-reload`
+
+Launch example `systemctl start test_iceoryx`
+
+Example of a stop `systemctl stop test_iceoryx`
+
 ## Build with script
 
 As an alternative, we provide a build-test script which we use to integrate iceoryx into our infrastructure.

iceoryx_meta/build_options.cmake

@@ -38,6 +38,7 @@ option(TEST_WITH_HUGE_PAYLOAD "Build Tests which use payload bigger than 2GB" OF
 option(TOML_CONFIG "TOML support for RouDi with dynamic configuration" ON)
 option(IOX_EXPERIMENTAL_POSH "Export experimental posh features (no guarantees)" OFF)
 option(IOX_REPRODUCIBLE_BUILD "Create reproducible builds by omit setting the build timestamp in the version header" ON)
+option(USE_SYSTEMD "Build with systemd support" OFF)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON) # "Create compile_commands.json file"
 
@@ -97,4 +98,5 @@ function(show_config_options)
   message("          TOML_CONFIG..........................: " ${TOML_CONFIG})
   message("          IOX_EXPERIMENTAL_POSH................: " ${IOX_EXPERIMENTAL_POSH})
   message("          IOX_REPRODUCIBLE_BUILD...............: " ${IOX_REPRODUCIBLE_BUILD})
+  message("          USE_SYSTEMD..........................: " ${USE_SYSTEMD})
 endfunction()

iceoryx_platform/cmake/IceoryxPackageHelper.cmake

@@ -237,6 +237,11 @@ Macro(iox_add_executable)
         target_compile_options(${IOX_TARGET} PRIVATE ${ICEORYX_CXX_FLAGS} ${ICEORYX_CXX_WARNINGS} ${ICEORYX_SANITIZER_FLAGS} ${ICEORYX_GRCOV_FLAGS})
     endif()
 
+    if(USE_SYSTEMD AND ("${IOX_TARGET}" STREQUAL "posh_moduletests"))
+        target_compile_definitions(${IOX_TARGET} PRIVATE USE_SYSTEMD_TEST=1)
+        message(STATUS "[i] Configuring ${IOX_TARGET} with systemd support.")
+    endif ()
+
     if ( IOX_STACK_SIZE )
         if(APPLE)
             # @todo iox-#1287 not yet supported
@@ -340,7 +345,14 @@ Macro(iox_add_library)
     target_include_directories(${IOX_TARGET} PUBLIC ${IOX_PUBLIC_INCLUDES} PRIVATE ${IOX_PRIVATE_INCLUDES})
 
     if ( LINUX )
-        target_link_libraries(${IOX_TARGET} PUBLIC ${IOX_PUBLIC_LIBS_LINUX} PRIVATE ${IOX_PRIVATE_LIBS_LINUX})
+        if(USE_SYSTEMD AND ("${IOX_TARGET}" STREQUAL "iceoryx_posh_roudi"))
+            message(STATUS "[i] Configuring ${IOX_TARGET} with systemd support.")
+            target_compile_definitions(${IOX_TARGET} PRIVATE USE_SYSTEMD=1)
+            target_link_libraries(${IOX_TARGET} PUBLIC ${IOX_PUBLIC_LIBS_LINUX} PRIVATE ${IOX_PRIVATE_LIBS_LINUX})
+#            target_link_libraries(${IOX_TARGET} PUBLIC ${IOX_PUBLIC_LIBS_LINUX} PRIVATE ${IOX_PRIVATE_LIBS_LINUX} systemd)
+        else()
+            target_link_libraries(${IOX_TARGET} PUBLIC ${IOX_PUBLIC_LIBS_LINUX} PRIVATE ${IOX_PRIVATE_LIBS_LINUX})
+        endif()
     elseif ( APPLE )
         target_link_libraries(${IOX_TARGET} PUBLIC ${IOX_PUBLIC_LIBS_APPLE} PRIVATE ${IOX_PRIVATE_LIBS_APPLE})
     elseif ( QNX )

iceoryx_posh/BUILD.bazel

@@ -53,6 +53,7 @@ configure_file(
             "IOX_MAX_SHM_SEGMENTS": "100",
             "IOX_MAX_SUBSCRIBERS": "1024",
             "IOX_MAX_SUBSCRIBERS_PER_PUBLISHER": "256",
+            "USE_SYSTEMD_FLAG": "false",
         },
         "//conditions:default": {
             "IOX_COMMUNICATION_POLICY": "ManyToManyPolicy",
@@ -80,6 +81,7 @@ configure_file(
             "IOX_MAX_SHM_SEGMENTS": "100",
             "IOX_MAX_SUBSCRIBERS": "1024",
             "IOX_MAX_SUBSCRIBERS_PER_PUBLISHER": "256",
+            "USE_SYSTEMD_FLAG": "false",
         },
     }),
 )

iceoryx_posh/CMakeLists.txt

@@ -183,6 +183,11 @@ iox_add_library(
 #
 ########## posh roudi lib ##########
 #
+set(SYSTEMD_LIB "")
+if (USE_SYSTEMD_FLAG)
+    set(SYSTEMD_LIB systemd)
+endif ()
+
 iox_add_library(
     NO_EXPORT
     NO_PACKAGE_SETUP
@@ -198,6 +203,7 @@ iox_add_library(
                         source/capro
                         source/roudi
     PRIVATE_LIBS_QNX    socket
+    PRIVATE_LIBS_LINUX  ${SYSTEMD_LIB}
     BUILD_INTERFACE     ${CMAKE_CURRENT_SOURCE_DIR}/include
     INSTALL_INTERFACE   include/${PREFIX}
     FILES

iceoryx_posh/cmake/IceoryxPoshDeployment.cmake

@@ -144,5 +144,12 @@ else()
 endif()
 message(STATUS "[i] IOX_EXPERIMENTAL_POSH_FLAG: ${IOX_EXPERIMENTAL_POSH_FLAG}")
 
+if(USE_SYSTEMD)
+    set(USE_SYSTEMD_FLAG true)
+else()
+    set(USE_SYSTEMD_FLAG false)
+endif()
+message(STATUS "[i] USE_SYSTEMD_FLAG: ${USE_SYSTEMD_FLAG}")
+
 message(STATUS "[i] <<<<<<<<<<<<<< End iceoryx_posh configuration: >>>>>>>>>>>>>>")
 

iceoryx_posh/cmake/iceoryx_posh_deployment.hpp.in

@@ -68,6 +68,7 @@ constexpr uint32_t IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY =
  constexpr uint32_t IOX_MAX_REQUESTS_PROCESSED_SIMULTANEOUSLY = static_cast<uint32_t>(@IOX_MAX_REQUESTS_PROCESSED_SIMULTANEOUSLY@);
  constexpr const char IOX_DEFAULT_RESOURCE_PREFIX[] = "@IOX_DEFAULT_RESOURCE_PREFIX@";
  constexpr bool IOX_EXPERIMENTAL_POSH_FLAG = @IOX_EXPERIMENTAL_POSH_FLAG@;
+ constexpr bool USE_SYSTEMD_FLAG = @USE_SYSTEMD_FLAG@;
 // clang-format on
 } // namespace build
 } // namespace iox

iceoryx_posh/include/iceoryx_posh/internal/roudi/roudi.hpp

@@ -18,6 +18,7 @@
 #define IOX_POSH_ROUDI_ROUDI_MULTI_PROCESS_HPP
 
 #include "iceoryx_platform/file.hpp"
+#include "iceoryx_platform/stdlib.hpp"
 #include "iceoryx_posh/iceoryx_posh_types.hpp"
 #include "iceoryx_posh/internal/roudi/introspection/mempool_introspection.hpp"
 #include "iceoryx_posh/internal/roudi/process_manager.hpp"
@@ -33,15 +34,206 @@
 #include "iox/scope_guard.hpp"
 #include "iox/smart_lock.hpp"
 
+
+#include <condition_variable>
 #include <cstdint>
 #include <thread>
 
+#ifdef USE_SYSTEMD
+#include <systemd/sd-daemon.h>
+#endif
+
+#ifdef USE_SYSTEMD
+namespace iox::roudi::service_management
+{
+class ServiceManagementSystemd;
+} // namespace iox::roudi::service_management
+using SendMessageServiceManagement = iox::roudi::service_management::ServiceManagementSystemd;
+#else
+namespace iox::roudi::service_management
+{
+class NoServiceManagementSystemd;
+} // namespace iox::roudi::service_management
+using SendMessageServiceManagement = iox::roudi::service_management::NoServiceManagementSystemd;
+#endif
+
 namespace iox
 {
 namespace roudi
 {
 using namespace iox::units::duration_literals;
 
+namespace service_management
+{
+/**
+ * @brief Interface class for systemd service handling
+ *
+ **/
+class ServiceManagement
+{
+  public:
+    virtual ~ServiceManagement() = default;
+    ServiceManagement(ServiceManagement const& other) = delete;
+    ServiceManagement(ServiceManagement&& other) = default;
+    ServiceManagement& operator=(ServiceManagement const& other) = delete;
+    ServiceManagement& operator=(ServiceManagement&& other) = default;
+
+    static constexpr const uint16_t SIZE_STRING = 4096;   ///< maximum size of string // 2
+    static constexpr const uint8_t SIZE_THREAD_NAME = 15; ///< max size for thread name // 1
+
+
+    virtual void processNotify() = 0;                                                /// dbus signal handler
+    virtual void shutdown() = 0;                                                     /// Sets a shutdown flag
+    virtual bool setThreadNameHelper(iox::string<SIZE_THREAD_NAME>& threadName) = 0; /// Sets a thread name
+    virtual std::string getEnvironmentVariable(const char* const env_var) = 0;       /// Get environment variable
+    virtual bool sendSDNotifySignalHelper(const std::string_view state) = 0;         /// Send notify
+
+  protected:
+    ServiceManagement() = default;
+};
+
+/**
+ * @brief Class to handle systemd service notifications
+ *
+ **/
+class ServiceManagementSystemd final : public ServiceManagement
+{
+  private:
+    std::condition_variable watchdogNotifyCondition; ///< watch dog notification condition // 48
+    std::mutex watchdogMutex;                        ///< watch dog mutex // 40
+    std::thread m_listenThreadWatchdog;              ///< thread that listens to systemd watchdog signals // 8
+    std::atomic_bool m_shutdown{false};              ///< indicates if service is being shutdown // 1
+
+  public:
+    ServiceManagementSystemd() = default;
+    ServiceManagementSystemd(ServiceManagementSystemd const& other) = delete;
+    ServiceManagementSystemd(ServiceManagementSystemd&& other) = delete;
+    ServiceManagementSystemd& operator=(ServiceManagementSystemd const& other) = delete;
+    ServiceManagementSystemd& operator=(ServiceManagementSystemd&& other) = delete;
+
+    /**
+     * @brief Destructor joins the listenThreadWatchdog if it is still joinable, to ensure a proper termination
+     **/
+    ~ServiceManagementSystemd() final;
+
+    /**
+     * @brief Sets the shutdown flag to true, causing the systemd handler to stop.
+     **/
+    void shutdown() final;
+
+    /**
+     * @brief Fetch required environment variable as a string
+     * @param env_var Pointer to environment variable
+     * @return Environment variable as std::string
+     **/
+    std::string getEnvironmentVariable(const char* const env_var) final;
+
+    /**
+     * @brief Helper function to set thread name
+     * @param threadName Thread name to be set
+     * @return True if successfully set, otherwise false
+     **/
+    bool setThreadNameHelper(iox::string<SIZE_THREAD_NAME>& threadName) final;
+
+    /**
+     * @brief Helper function to send SDNotify signals
+     * @param state SDNotify state to be sent
+     * @return True if signal sending is successful, otherwise false
+     **/
+#ifdef USE_SYSTEMD
+    bool sendSDNotifySignalHelper(const std::string_view state) final
+    {
+        auto result = IOX_POSIX_CALL(sd_notify)(0, state.data()).successReturnValue(1).evaluate();
+        if (result.has_error())
+        {
+            IOX_LOG(ERROR,
+                    "Failed to send " << state.data()
+                                      << " signal. Error: " << result.get_error().getHumanReadableErrnum());
+            return false;
+        }
+        return true;
+    }
+#else
+    bool sendSDNotifySignalHelper([[maybe_unused]] const std::string_view state) final
+    {
+        // empty implementation
+        return true;
+    }
+#endif
+    /**
+     * @brief Function to manage the watchdog loop
+     **/
+    void watchdogLoopHelper();
+
+    /**
+     * @brief Method to process systemd notification logic
+     **/
+    void processNotify() final;
+};
+
+/**
+ * @brief Empty implementation handler for non-systemd systems
+ *
+ **/
+class NoServiceManagementSystemd final : public ServiceManagement
+{
+  public:
+    NoServiceManagementSystemd() = default;
+    NoServiceManagementSystemd(NoServiceManagementSystemd const& other) = delete;
+    NoServiceManagementSystemd(NoServiceManagementSystemd&& other) = default;
+    NoServiceManagementSystemd& operator=(NoServiceManagementSystemd const& other) = delete;
+    NoServiceManagementSystemd& operator=(NoServiceManagementSystemd&& other) = default;
+
+    /**
+     * @brief Empty implementation of destructor
+     **/
+    ~NoServiceManagementSystemd() final = default;
+
+    /**
+     * @brief Empty implementation of processNotify
+     **/
+    void processNotify() final
+    {
+        // empty implementation
+    }
+
+    /**
+     * @brief Empty implementation of shutdown
+     **/
+    void shutdown() final
+    {
+        // empty implementation
+    }
+
+    /**
+     * @brief Empty implementation of get environment variable
+     **/
+    std::string getEnvironmentVariable([[maybe_unused]] const char* const env_var) final
+    {
+        // empty implementation
+        return "no implement";
+    }
+
+    /**
+     * @brief Empty implementation set thread name
+     **/
+    bool setThreadNameHelper([[maybe_unused]] iox::string<SIZE_THREAD_NAME>& threadName) final
+    {
+        // empty implementation
+        return true;
+    }
+
+    /**
+     * @brief Empty implementation send SDNotify signals
+     **/
+    bool sendSDNotifySignalHelper([[maybe_unused]] const std::string_view state) final
+    {
+        // empty implementation
+        return true;
+    }
+};
+} // namespace service_management
+
 class RouDi
 {
   public: